test_sorcery_memory_cache_thrash.c File Reference

Sorcery Unit Tests. More...

#include "asterisk.h"
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/sorcery.h"
#include "asterisk/logger.h"
#include "asterisk/vector.h"
#include "asterisk/cli.h"

Include dependency graph for test_sorcery_memory_cache_thrash.c:

Go to the source code of this file.

Data Structures
struct	sorcery_memory_cache_thrash
	Structure for memory cache thrashing. More...
struct	sorcery_memory_cache_thrash_thread
	Structure for a memory cache thras thread. More...
struct	test_data
	Sorcery object created based on backend data. More...

Macros
#define	TEST_THRASH_RETRIEVERS   25
	The number of threads to use for retrieving for applicable tests.
#define	TEST_THRASH_TIME   3
	The default amount of time (in seconds) that thrash unit tests execute for.
#define	TEST_THRASH_UPDATERS   25
	The number of threads to use for updating for applicable tests.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (conflicting_expire_and_stale)
	AST_TEST_DEFINE (high_object_count_without_expiration)
	AST_TEST_DEFINE (low_unique_object_count_high_concurrent_updates)
	AST_TEST_DEFINE (low_unique_object_count_immediately_expire)
	AST_TEST_DEFINE (low_unique_object_count_immediately_stale)
	AST_TEST_DEFINE (unique_objects_exceeding_maximum)
	AST_TEST_DEFINE (unique_objects_exceeding_maximum_with_expire_and_stale)
static int	load_module (void)
static void *	mock_retrieve_id (const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
	Callback for retrieving sorcery object by ID.
static int	mock_update (const struct ast_sorcery *sorcery, void *data, void *object)
	Callback for updating a sorcery object.
static enum ast_test_result_state	nominal_thrash (struct ast_test *test, const char *cache_configuration, unsigned int thrash_time, unsigned int unique_objects, unsigned int retrieve_threads, unsigned int update_threads)
static char *	sorcery_memory_cache_cli_thrash (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct sorcery_memory_cache_thrash *	sorcery_memory_cache_thrash_create (const char *cache_configuration, unsigned int update_threads, unsigned int retrieve_threads, unsigned int unique_objects)
static void	sorcery_memory_cache_thrash_destroy (void *obj)
static void *	sorcery_memory_cache_thrash_retrieve (void *data)
static int	sorcery_memory_cache_thrash_start (struct sorcery_memory_cache_thrash *thrash)
static void	sorcery_memory_cache_thrash_stop (struct sorcery_memory_cache_thrash *thrash)
static void *	sorcery_memory_cache_thrash_update (void *data)
static void *	test_data_alloc (const char *id)
	Allocation callback for test_data sorcery object.
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Cache Thrasing test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_memory_cache_thrash []
static struct ast_sorcery_wizard	mock_wizard
	A mock sorcery wizard used for the stale test.

Detailed Description

Sorcery Unit Tests.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file test_sorcery_memory_cache_thrash.c.

Macro Definition Documentation

TEST_THRASH_RETRIEVERS

#define TEST_THRASH_RETRIEVERS   25

The number of threads to use for retrieving for applicable tests.

Definition at line 45 of file test_sorcery_memory_cache_thrash.c.

TEST_THRASH_TIME

#define TEST_THRASH_TIME   3

The default amount of time (in seconds) that thrash unit tests execute for.

Definition at line 42 of file test_sorcery_memory_cache_thrash.c.

TEST_THRASH_UPDATERS

#define TEST_THRASH_UPDATERS   25

The number of threads to use for updating for applicable tests.

Definition at line 48 of file test_sorcery_memory_cache_thrash.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 631 of file test_sorcery_memory_cache_thrash.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 631 of file test_sorcery_memory_cache_thrash.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 631 of file test_sorcery_memory_cache_thrash.c.

AST_TEST_DEFINE() [1/7]

AST_TEST_DEFINE

(

conflicting_expire_and_stale

)

Definition at line 566 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "conflicting_expire_and_stale";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with a large number of objects that expire and go stale";
        info->description = "This test creates a cache with a large number of objects that expire\n"
            "and go stale. As there is such a large number this ensures that both operations occur.\n"
            "This test confirms that stale refreshing and expiration do not conflict.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "object_lifetime_maximum=2,object_lifetime_stale=1", TEST_THRASH_TIME * 2, 5000,
        TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

AST_TEST_DEFINE() [2/7]

AST_TEST_DEFINE

(

high_object_count_without_expiration

)

Definition at line 585 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "high_object_count_without_expiration";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with a large number of objects";
        info->description = "This test creates a cache with a large number of objects that persist.\n"
            "A large number of threads are created which constantly retrieve from the cache.\n"
            "This test confirms that the large number of retrieves do not cause a problem.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "default", TEST_THRASH_TIME, 5000, TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

AST_TEST_DEFINE() [3/7]

AST_TEST_DEFINE

(

low_unique_object_count_high_concurrent_updates

)

Definition at line 506 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "low_unique_object_count_high_concurrent_updates";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with low number of unique objects that are updated frequently";
        info->description = "This test creates a cache with objects that are being constantly\n"
            "updated and retrieved at the same time. This will create contention between all\n"
            "of the threads as the write lock is held for the updates. This test confirms that\n"
            "no problems occur in this situation.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "default", TEST_THRASH_TIME, 10, TEST_THRASH_RETRIEVERS, TEST_THRASH_UPDATERS);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, TEST_THRASH_TIME, and TEST_THRASH_UPDATERS.

AST_TEST_DEFINE() [4/7]

AST_TEST_DEFINE

(

low_unique_object_count_immediately_expire

)

Definition at line 487 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "low_unique_object_count_immediately_expire";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with low number of unique objects that are immediately expired";
        info->description = "This test creates a cache with objects that are expired\n"
            "after 1 second. It also creates 25 threads which are constantly attempting\n"
            "to retrieve the objects. This test confirms that the expiration process does\n"
            "not cause a problem as the retrieve threads execute.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "object_lifetime_maximum=1", TEST_THRASH_TIME, 10, TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

AST_TEST_DEFINE() [5/7]

AST_TEST_DEFINE

(

low_unique_object_count_immediately_stale

)

Definition at line 467 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "low_unique_object_count_immediately_stale";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with low number of unique objects that are immediately stale";
        info->description = "This test creates a cache with objects that are stale\n"
            "after 1 second. It also creates 25 threads which are constantly attempting\n"
            "to retrieve the objects. This test confirms that the background refreshes\n"
            "being done as a result of going stale do not conflict or cause problems with\n"
            "the large number of retrieve threads.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "object_lifetime_stale=1", TEST_THRASH_TIME, 10, TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

AST_TEST_DEFINE() [6/7]

AST_TEST_DEFINE

(

unique_objects_exceeding_maximum

)

Definition at line 525 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "unique_objects_exceeding_maximum";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with a fixed maximum object count";
        info->description = "This test creates a cache with a maximum number of objects\n"
            "allowed in it. The maximum number of unique objects, however, far exceeds the\n"
            "the maximum number allowed in the cache. This test confirms that the cache does\n"
            "not exceed the maximum and that the removal of older objects does not cause\n"
            "a problem.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "maximum_objects=10", TEST_THRASH_TIME, 100, TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

AST_TEST_DEFINE() [7/7]

AST_TEST_DEFINE

(

unique_objects_exceeding_maximum_with_expire_and_stale

)

Definition at line 545 of file test_sorcery_memory_cache_thrash.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "unique_objects_exceeding_maximum_with_expire_and_stale";
        info->category = "/res/res_sorcery_memory_cache/thrash/";
        info->summary = "Thrash a cache with a fixed maximum object count with objects that expire and go stale";
        info->description = "This test creates a cache with a maximum number of objects\n"
            "allowed in it with objects that also go stale after a period of time and expire.\n"
            "A number of threads are created that constantly retrieve from the cache, causing\n"
            "both stale refresh and expiration to occur. This test confirms that the combination\n"
            "of these do not present a problem.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return nominal_thrash(test, "maximum_objects=10,object_lifetime_maximum=2,object_lifetime_stale=1",
        TEST_THRASH_TIME * 2, 100, TEST_THRASH_RETRIEVERS, 0);
}

References AST_TEST_NOT_RUN, nominal_thrash(), TEST_EXECUTE, TEST_INIT, TEST_THRASH_RETRIEVERS, and TEST_THRASH_TIME.

load_module()

static int load_module ( void  )

static

Definition at line 617 of file test_sorcery_memory_cache_thrash.c.

{
    ast_cli_register_multiple(cli_memory_cache_thrash, ARRAY_LEN(cli_memory_cache_thrash));
    AST_TEST_REGISTER(low_unique_object_count_immediately_stale);
    AST_TEST_REGISTER(low_unique_object_count_immediately_expire);
    AST_TEST_REGISTER(low_unique_object_count_high_concurrent_updates);
    AST_TEST_REGISTER(unique_objects_exceeding_maximum);
    AST_TEST_REGISTER(unique_objects_exceeding_maximum_with_expire_and_stale);
    AST_TEST_REGISTER(conflicting_expire_and_stale);
    AST_TEST_REGISTER(high_object_count_without_expiration);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, and cli_memory_cache_thrash.

mock_retrieve_id()

static void * mock_retrieve_id ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const char *  id  )

static

Callback for retrieving sorcery object by ID.

Parameters

sorcery	The sorcery instance
data	Unused
type	The object type. Will always be "test".
id	The object id. Will always be "test".

Return values

NULL	Backend data successfully allocated
non-NULL	Backend data could not be successfully allocated

Definition at line 106 of file test_sorcery_memory_cache_thrash.c.

{
    return ast_sorcery_alloc(sorcery, type, id);
}

References ast_sorcery_alloc(), sorcery, and type.

mock_update()

static int mock_update ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Callback for updating a sorcery object.

Parameters

sorcery	The sorcery instance
data	Unused
object	The object to update.

Definition at line 120 of file test_sorcery_memory_cache_thrash.c.

{
    return 0;
}

nominal_thrash()

static enum ast_test_result_state nominal_thrash ( struct ast_test *  test, const char *  cache_configuration, unsigned int  thrash_time, unsigned int  unique_objects, unsigned int  retrieve_threads, unsigned int  update_threads  )

static

Definition at line 447 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash *thrash;
 
    thrash = sorcery_memory_cache_thrash_create(cache_configuration, update_threads, retrieve_threads, unique_objects);
    if (!thrash) {
        return AST_TEST_FAIL;
    }
 
    sorcery_memory_cache_thrash_start(thrash);
    while ((thrash_time = sleep(thrash_time)));
    sorcery_memory_cache_thrash_stop(thrash);
 
    ao2_ref(thrash, -1);
 
    return AST_TEST_PASS;
}

References ao2_ref, AST_TEST_FAIL, AST_TEST_PASS, sorcery_memory_cache_thrash::retrieve_threads, sorcery_memory_cache_thrash_create(), sorcery_memory_cache_thrash_start(), sorcery_memory_cache_thrash_stop(), and sorcery_memory_cache_thrash::update_threads.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

sorcery_memory_cache_cli_thrash()

static char * sorcery_memory_cache_cli_thrash ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 368 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash *thrash;
    unsigned int thrash_time, unique_objects, retrieve_threads, update_threads;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "sorcery memory cache thrash";
        e->usage =
            "Usage: sorcery memory cache thrash <cache configuration> <amount of time to thrash the cache> <number of unique objects> <number of retrieve threads> <number of update threads>\n"
            "       Create a sorcery instance with a memory cache using the provided configuration and thrash it.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 9) {
        return CLI_SHOWUSAGE;
    }
 
    if (sscanf(a->argv[5], "%30u", &thrash_time) != 1) {
        ast_cli(a->fd, "An invalid value of '%s' has been provided for the thrashing time\n", a->argv[5]);
        return CLI_FAILURE;
    } else if (sscanf(a->argv[6], "%30u", &unique_objects) != 1) {
        ast_cli(a->fd, "An invalid value of '%s' has been provided for number of unique objects\n", a->argv[6]);
        return CLI_FAILURE;
    } else if (sscanf(a->argv[7], "%30u", &retrieve_threads) != 1) {
        ast_cli(a->fd, "An invalid value of '%s' has been provided for the number of retrieve threads\n", a->argv[7]);
        return CLI_FAILURE;
    } else if (sscanf(a->argv[8], "%30u", &update_threads) != 1) {
        ast_cli(a->fd, "An invalid value of '%s' has been provided for the number of update threads\n", a->argv[8]);
        return CLI_FAILURE;
    }
 
    thrash = sorcery_memory_cache_thrash_create(a->argv[4], update_threads, retrieve_threads, unique_objects);
    if (!thrash) {
        ast_cli(a->fd, "Could not create a sorcery memory cache thrash test using the provided arguments\n");
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, "Starting cache thrash test.\n");
    ast_cli(a->fd, "Memory cache configuration: %s\n", a->argv[4]);
    ast_cli(a->fd, "Amount of time to perform test: %u seconds\n", thrash_time);
    ast_cli(a->fd, "Number of unique objects: %u\n", unique_objects);
    ast_cli(a->fd, "Number of retrieve threads: %u\n", retrieve_threads);
    ast_cli(a->fd, "Number of update threads: %u\n", update_threads);
 
    sorcery_memory_cache_thrash_start(thrash);
    while ((thrash_time = sleep(thrash_time)));
    sorcery_memory_cache_thrash_stop(thrash);
 
    ast_cli(a->fd, "Stopped cache thrash test\n");
 
    ast_cli(a->fd, "Average retrieve execution time (in milliseconds): %u\n", thrash->average_retrieve_execution_time);
    ast_cli(a->fd, "Average update execution time (in milliseconds): %u\n", thrash->average_update_execution_time);
 
    ao2_ref(thrash, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_ref, ast_cli(), sorcery_memory_cache_thrash::average_retrieve_execution_time, sorcery_memory_cache_thrash::average_update_execution_time, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, sorcery_memory_cache_thrash::retrieve_threads, sorcery_memory_cache_thrash_create(), sorcery_memory_cache_thrash_start(), sorcery_memory_cache_thrash_stop(), sorcery_memory_cache_thrash::update_threads, and ast_cli_entry::usage.

sorcery_memory_cache_thrash_create()

static struct sorcery_memory_cache_thrash * sorcery_memory_cache_thrash_create ( const char *  cache_configuration, unsigned int  update_threads, unsigned int  retrieve_threads, unsigned int  unique_objects  )

static

Definition at line 173 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash *thrash;
    struct sorcery_memory_cache_thrash_thread *thread;
    unsigned int total_threads = update_threads + retrieve_threads;
 
    thrash = ao2_alloc_options(sizeof(*thrash), sorcery_memory_cache_thrash_destroy,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!thrash) {
        return NULL;
    }
 
    thrash->update_threads = update_threads;
    thrash->retrieve_threads = retrieve_threads;
 
    ast_sorcery_wizard_register(&mock_wizard);
 
    thrash->sorcery = ast_sorcery_open();
    if (!thrash->sorcery) {
        ao2_ref(thrash, -1);
        return NULL;
    }
 
    ast_sorcery_apply_wizard_mapping(thrash->sorcery, "test", "memory_cache",
            !strcmp(cache_configuration, "default") ? "" : cache_configuration, 1);
    ast_sorcery_apply_wizard_mapping(thrash->sorcery, "test", "mock", NULL, 0);
    ast_sorcery_internal_object_register(thrash->sorcery, "test", test_data_alloc, NULL, NULL);
 
    if (AST_VECTOR_INIT(&thrash->threads, update_threads + retrieve_threads)) {
        ao2_ref(thrash, -1);
        return NULL;
    }
 
    while (AST_VECTOR_SIZE(&thrash->threads) != total_threads) {
        thread = ast_calloc(1, sizeof(*thread));
 
        if (!thread) {
            ao2_ref(thrash, -1);
            return NULL;
        }
 
        thread->thread = AST_PTHREADT_NULL;
        thread->unique_objects = unique_objects;
 
        /* This purposely holds no ref as the main thrash structure does */
        thread->sorcery = thrash->sorcery;
 
        if (AST_VECTOR_APPEND(&thrash->threads, thread)) {
            ast_free(thread);
            ao2_ref(thrash, -1);
            return NULL;
        }
    }
 
    return thrash;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_calloc, ast_free, AST_PTHREADT_NULL, ast_sorcery_apply_wizard_mapping, ast_sorcery_internal_object_register, ast_sorcery_open, ast_sorcery_wizard_register, AST_VECTOR_APPEND, AST_VECTOR_INIT, AST_VECTOR_SIZE, mock_wizard, NULL, sorcery_memory_cache_thrash::retrieve_threads, sorcery_memory_cache_thrash::sorcery, sorcery_memory_cache_thrash_destroy(), test_data_alloc(), thread, sorcery_memory_cache_thrash::threads, sorcery_memory_cache_thrash_thread::unique_objects, and sorcery_memory_cache_thrash::update_threads.

Referenced by nominal_thrash(), and sorcery_memory_cache_cli_thrash().

sorcery_memory_cache_thrash_destroy()

static void sorcery_memory_cache_thrash_destroy ( void *  obj )

static

Definition at line 141 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash *thrash = obj;
    int idx;
 
    if (thrash->sorcery) {
        ast_sorcery_unref(thrash->sorcery);
    }
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&thrash->threads); ++idx) {
        struct sorcery_memory_cache_thrash_thread *thread;
 
        thread = AST_VECTOR_GET(&thrash->threads, idx);
        ast_free(thread);
    }
    AST_VECTOR_FREE(&thrash->threads);
 
    ast_sorcery_wizard_unregister(&mock_wizard);
}

References ast_free, ast_sorcery_unref, ast_sorcery_wizard_unregister(), AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_SIZE, mock_wizard, sorcery_memory_cache_thrash::sorcery, thread, and sorcery_memory_cache_thrash::threads.

Referenced by sorcery_memory_cache_thrash_create().

sorcery_memory_cache_thrash_retrieve()

static void * sorcery_memory_cache_thrash_retrieve ( void *  data )

static

Definition at line 267 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash_thread *thread = data;
    struct timeval start;
    unsigned int object_id;
    char object_id_str[AST_UUID_STR_LEN];
    void *object;
 
    while (!thread->stop) {
        object_id = ast_random() % thread->unique_objects;
        snprintf(object_id_str, sizeof(object_id_str), "%u", object_id);
 
        start = ast_tvnow();
        object = ast_sorcery_retrieve_by_id(thread->sorcery, "test", object_id_str);
        thread->average_execution_time = (thread->average_execution_time + ast_tvdiff_ms(ast_tvnow(), start)) / 2;
        ast_assert(object != NULL);
 
        ao2_ref(object, -1);
    }
 
    return NULL;
}

References ao2_ref, ast_assert, ast_random(), ast_sorcery_retrieve_by_id(), ast_tvdiff_ms(), ast_tvnow(), AST_UUID_STR_LEN, NULL, thread, and sorcery_memory_cache_thrash_thread::unique_objects.

Referenced by sorcery_memory_cache_thrash_start().

sorcery_memory_cache_thrash_start()

static int sorcery_memory_cache_thrash_start ( struct sorcery_memory_cache_thrash *  thrash )

static

Definition at line 345 of file test_sorcery_memory_cache_thrash.c.

{
    int idx;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&thrash->threads); ++idx) {
        struct sorcery_memory_cache_thrash_thread *thread;
 
        thread = AST_VECTOR_GET(&thrash->threads, idx);
 
        if (ast_pthread_create(&thread->thread, NULL, idx < thrash->update_threads ?
            sorcery_memory_cache_thrash_update : sorcery_memory_cache_thrash_retrieve, thread)) {
            sorcery_memory_cache_thrash_stop(thrash);
            return -1;
        }
    }
 
    return 0;
}

References ast_pthread_create, AST_VECTOR_GET, AST_VECTOR_SIZE, NULL, sorcery_memory_cache_thrash_retrieve(), sorcery_memory_cache_thrash_stop(), sorcery_memory_cache_thrash_update(), thread, and sorcery_memory_cache_thrash::threads.

Referenced by nominal_thrash(), and sorcery_memory_cache_cli_thrash().

sorcery_memory_cache_thrash_stop()

static void sorcery_memory_cache_thrash_stop ( struct sorcery_memory_cache_thrash *  thrash )

static

Definition at line 296 of file test_sorcery_memory_cache_thrash.c.

{
    int idx;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&thrash->threads); ++idx) {
        struct sorcery_memory_cache_thrash_thread *thread;
 
        thread = AST_VECTOR_GET(&thrash->threads, idx);
        if (thread->thread == AST_PTHREADT_NULL) {
            continue;
        }
 
        thread->stop = 1;
    }
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&thrash->threads); ++idx) {
        struct sorcery_memory_cache_thrash_thread *thread;
 
        thread = AST_VECTOR_GET(&thrash->threads, idx);
        if (thread->thread == AST_PTHREADT_NULL) {
            continue;
        }
 
        pthread_join(thread->thread, NULL);
 
        if (idx < thrash->update_threads) {
            thrash->average_update_execution_time += thread->average_execution_time;
        } else {
            thrash->average_retrieve_execution_time += thread->average_execution_time;
        }
    }
 
    if (thrash->update_threads) {
        thrash->average_update_execution_time /= thrash->update_threads;
    }
    if (thrash->retrieve_threads) {
        thrash->average_retrieve_execution_time /= thrash->retrieve_threads;
    }
}

References AST_PTHREADT_NULL, AST_VECTOR_GET, AST_VECTOR_SIZE, sorcery_memory_cache_thrash::average_retrieve_execution_time, sorcery_memory_cache_thrash::average_update_execution_time, NULL, sorcery_memory_cache_thrash::retrieve_threads, thread, sorcery_memory_cache_thrash::threads, and sorcery_memory_cache_thrash::update_threads.

Referenced by nominal_thrash(), sorcery_memory_cache_cli_thrash(), and sorcery_memory_cache_thrash_start().

sorcery_memory_cache_thrash_update()

static void * sorcery_memory_cache_thrash_update ( void *  data )

static

Definition at line 237 of file test_sorcery_memory_cache_thrash.c.

{
    struct sorcery_memory_cache_thrash_thread *thread = data;
    struct timeval start;
    unsigned int object_id;
    char object_id_str[AST_UUID_STR_LEN];
    void *object;
 
    while (!thread->stop) {
        object_id = ast_random() % thread->unique_objects;
        snprintf(object_id_str, sizeof(object_id_str), "%u", object_id);
 
        object = ast_sorcery_alloc(thread->sorcery, "test", object_id_str);
        ast_assert(object != NULL);
 
        start = ast_tvnow();
        ast_sorcery_update(thread->sorcery, object);
        thread->average_execution_time = (thread->average_execution_time + ast_tvdiff_ms(ast_tvnow(), start)) / 2;
        ao2_ref(object, -1);
    }
 
    return NULL;
}

References ao2_ref, ast_assert, ast_random(), ast_sorcery_alloc(), ast_sorcery_update(), ast_tvdiff_ms(), ast_tvnow(), AST_UUID_STR_LEN, NULL, thread, and sorcery_memory_cache_thrash_thread::unique_objects.

Referenced by sorcery_memory_cache_thrash_start().

test_data_alloc()

static void * test_data_alloc ( const char *  id )

static

Allocation callback for test_data sorcery object.

Definition at line 90 of file test_sorcery_memory_cache_thrash.c.

{
    return ast_sorcery_generic_alloc(sizeof(struct test_data), NULL);
}

References ast_sorcery_generic_alloc(), and NULL.

Referenced by sorcery_memory_cache_thrash_create().

unload_module()

static int unload_module ( void  )

static

Definition at line 603 of file test_sorcery_memory_cache_thrash.c.

{
    ast_cli_unregister_multiple(cli_memory_cache_thrash, ARRAY_LEN(cli_memory_cache_thrash));
    AST_TEST_UNREGISTER(low_unique_object_count_immediately_stale);
    AST_TEST_UNREGISTER(low_unique_object_count_immediately_expire);
    AST_TEST_UNREGISTER(low_unique_object_count_high_concurrent_updates);
    AST_TEST_UNREGISTER(unique_objects_exceeding_maximum);
    AST_TEST_UNREGISTER(unique_objects_exceeding_maximum_with_expire_and_stale);
    AST_TEST_UNREGISTER(conflicting_expire_and_stale);
    AST_TEST_UNREGISTER(high_object_count_without_expiration);
 
    return 0;
}

References ARRAY_LEN, ast_cli_unregister_multiple(), AST_TEST_UNREGISTER, and cli_memory_cache_thrash.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Cache Thrasing test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 631 of file test_sorcery_memory_cache_thrash.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 631 of file test_sorcery_memory_cache_thrash.c.

cli_memory_cache_thrash

struct ast_cli_entry cli_memory_cache_thrash[]

static

Initial value:

= {
    { .handler =  sorcery_memory_cache_cli_thrash , .summary =  "Thrash a sorcery memory cache" ,},
}

Definition at line 429 of file test_sorcery_memory_cache_thrash.c.

                                                        {
    AST_CLI_DEFINE(sorcery_memory_cache_cli_thrash, "Thrash a sorcery memory cache"),
};

Referenced by load_module(), and unload_module().

mock_wizard

struct ast_sorcery_wizard mock_wizard

static

Initial value:

= {
    .name = "mock",
    .retrieve_id = mock_retrieve_id,
    .update = mock_update,
}

A mock sorcery wizard used for the stale test.

Definition at line 129 of file test_sorcery_memory_cache_thrash.c.

                                               {
    .name = "mock",
    .retrieve_id = mock_retrieve_id,
    .update = mock_update,
};

Referenced by sorcery_memory_cache_thrash_create(), and sorcery_memory_cache_thrash_destroy().