test_astobj2_thrash.c File Reference

#include "asterisk.h"
#include <pthread.h>
#include "asterisk/astobj2.h"
#include "asterisk/hashtab.h"
#include "asterisk/lock.h"
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/time.h"
#include "asterisk/utils.h"

Include dependency graph for test_astobj2_thrash.c:

Go to the source code of this file.

Data Structures
struct	hash_test

Macros
#define	COUNT_SLEEP_US   500
#define	HASH_BUCKETS   151
#define	MAX_HASH_ENTRIES   15000
#define	MAX_TEST_SECONDS   60

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (hash_test)
static int	compare_strings (void *lhs, void *rhs, int flags)
static int	hash_string (const void *obj, const int flags)
static void *	hash_test_count (void *d)
static void *	hash_test_grow (void *d)
	Grow the hash data as specified. More...
static void *	hash_test_lookup (void *d)
static void *	hash_test_shrink (void *d)
static void	ht_delete (void *obj)
	Free test element. More...
static char *	ht_new (int i)
	Create test element. More...
static int	increment_count (void *obj, void *arg, int flags)
static int	is_timed_out (struct hash_test const *data)
static int	load_module (void)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "astobj2 container thrash test" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static int	alloc_count = 0
static const struct ast_module_info *	ast_module_info = &__mod_info

Macro Definition Documentation

COUNT_SLEEP_US

#define COUNT_SLEEP_US   500

Definition at line 54 of file test_astobj2_thrash.c.

HASH_BUCKETS

#define HASH_BUCKETS   151

Definition at line 52 of file test_astobj2_thrash.c.

MAX_HASH_ENTRIES

#define MAX_HASH_ENTRIES   15000

Definition at line 47 of file test_astobj2_thrash.c.

MAX_TEST_SECONDS

#define MAX_TEST_SECONDS   60

Definition at line 55 of file test_astobj2_thrash.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 359 of file test_astobj2_thrash.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 359 of file test_astobj2_thrash.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 359 of file test_astobj2_thrash.c.

AST_TEST_DEFINE()

AST_TEST_DEFINE

(

hash_test

)

Definition at line 247 of file test_astobj2_thrash.c.

{
    enum ast_test_result_state res = AST_TEST_PASS;
    struct hash_test data = {};
    pthread_t grow_thread, count_thread, lookup_thread, shrink_thread;
    void *thread_results;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "thrash";
        info->category = "/main/astobj2/";
        info->summary = "Testing astobj2 container concurrency";
        info->description = "Test astobj2 container concurrency correctness.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing hash concurrency test...\n");
    data.preload = MAX_HASH_ENTRIES / 2;
    data.max_grow = MAX_HASH_ENTRIES - data.preload;
    data.deadline = ast_tvadd(ast_tvnow(), ast_tv(MAX_TEST_SECONDS, 0));
    data.to_be_thrashed = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        HASH_BUCKETS, hash_string, NULL, compare_strings);
 
    if (data.to_be_thrashed == NULL) {
        ast_test_status_update(test, "Allocation failed\n");
        /* Nothing needs to be freed; early return is fine */
        return AST_TEST_FAIL;
    }
 
    /* preload with data to delete */
    for (i = 1; i < data.preload; ++i) {
        char *ht = ht_new(-i);
        if (ht == NULL) {
            ast_test_status_update(test, "Allocation failed\n");
            ao2_ref(data.to_be_thrashed, -1);
            return AST_TEST_FAIL;
        }
        ao2_link(data.to_be_thrashed, ht);
        ao2_ref(ht, -1);
    }
 
    /* add data.max_grow entries to the ao2 container */
    ast_pthread_create(&grow_thread, NULL, hash_test_grow, &data);
    /* continually count the keys added by the grow thread */
    ast_pthread_create(&count_thread, NULL, hash_test_count, &data);
    /* continually lookup keys added by the grow thread */
    ast_pthread_create(&lookup_thread, NULL, hash_test_lookup, &data);
    /* delete all keys preloaded into the ao2 container */
    ast_pthread_create(&shrink_thread, NULL, hash_test_shrink, &data);
 
    pthread_join(grow_thread, &thread_results);
    if (thread_results != NULL) {
        ast_test_status_update(test, "Growth thread failed: %s\n",
            (char *)thread_results);
        res = AST_TEST_FAIL;
    }
 
    pthread_join(count_thread, &thread_results);
    if (thread_results != NULL) {
        ast_test_status_update(test, "Count thread failed: %s\n",
            (char *)thread_results);
        res = AST_TEST_FAIL;
    }
 
    pthread_join(lookup_thread, &thread_results);
    if (thread_results != NULL) {
        ast_test_status_update(test, "Lookup thread failed: %s\n",
            (char *)thread_results);
        res = AST_TEST_FAIL;
    }
 
    pthread_join(shrink_thread, &thread_results);
    if (thread_results != NULL) {
        ast_test_status_update(test, "Shrink thread failed: %s\n",
            (char *)thread_results);
        res = AST_TEST_FAIL;
    }
 
    if (ao2_container_count(data.to_be_thrashed) != data.max_grow) {
        ast_test_status_update(test,
            "Invalid ao2 container size. Expected: %d, Actual: %d\n",
            data.max_grow, ao2_container_count(data.to_be_thrashed));
        res = AST_TEST_FAIL;
    }
 
    ao2_ref(data.to_be_thrashed, -1);
 
    /* check for object leaks */
    if (ast_atomic_fetchadd_int(&alloc_count, 0) != 0) {
        ast_test_status_update(test, "Leaked %d objects!\n",
            ast_atomic_fetchadd_int(&alloc_count, 0));
        res = AST_TEST_FAIL;
    }
 
    return res;
}

References alloc_count, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_container_count(), ao2_link, ao2_ref, ast_atomic_fetchadd_int(), ast_pthread_create, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tv(), ast_tvadd(), ast_tvnow(), compare_strings(), hash_test::deadline, HASH_BUCKETS, hash_string(), hash_test_count(), hash_test_grow(), hash_test_lookup(), hash_test_shrink(), ht_new(), sip_to_pjsip::info(), hash_test::max_grow, MAX_HASH_ENTRIES, MAX_TEST_SECONDS, NULL, hash_test::preload, TEST_EXECUTE, TEST_INIT, and hash_test::to_be_thrashed.

compare_strings()

static int compare_strings ( void *  lhs, void *  rhs, int  flags  )

static

Definition at line 236 of file test_astobj2_thrash.c.

{
    const char *lhs_str = lhs;
    const char *rhs_str = rhs;
    if (strcasecmp(lhs_str, rhs_str) == 0) {
        return CMP_MATCH | CMP_STOP;
    } else {
        return 0;
    }
}

References CMP_MATCH, and CMP_STOP.

Referenced by AST_TEST_DEFINE().

hash_string()

static int hash_string ( const void *  obj, const int  flags  )

static

Definition at line 231 of file test_astobj2_thrash.c.

{
    return ast_hashtab_hash_string_nocase(obj);
}

References ast_hashtab_hash_string_nocase().

Referenced by AST_TEST_DEFINE().

hash_test_count()

static void * hash_test_count ( void *  d )

static

Continuously iterate through all the entries in the hash

Definition at line 203 of file test_astobj2_thrash.c.

{
    const struct hash_test *data = d;
    int count = 0;
    int last_count = 0;
 
    while (count < data->max_grow) {
        last_count = count;
        count = 0;
        ao2_callback(data->to_be_thrashed, OBJ_MULTIPLE, increment_count, &count);
 
        if (last_count == count) {
            /* Allow other threads to run. */
            usleep(COUNT_SLEEP_US);
        } else if (last_count > count) {
            /* Make sure the ao2 container never shrinks */
            return "ao2 container unexpectedly shrank";
        }
 
        if (is_timed_out(data)) {
            return "Count timed out";
        }
    }
 
    /* Successfully iterated over all of the expected elements */
    return NULL;
}

References ao2_callback, COUNT_SLEEP_US, d, increment_count(), is_timed_out(), hash_test::max_grow, NULL, OBJ_MULTIPLE, and hash_test::to_be_thrashed.

Referenced by AST_TEST_DEFINE().

hash_test_grow()

static void * hash_test_grow ( void *  d )

static

Grow the hash data as specified.

Definition at line 98 of file test_astobj2_thrash.c.

{
    struct hash_test *data = d;
    int i;
 
    for (i = 0; i < data->max_grow; ++i) {
        char *ht;
        if (is_timed_out(data)) {
            printf("Growth timed out at %d\n", i);
            return "Growth timed out";
        }
        ht = ht_new(i);
        if (ht == NULL) {
            return "Allocation failed";
        }
        ao2_link(data->to_be_thrashed, ht);
        ao2_ref(ht, -1);
        ast_atomic_fetchadd_int(&data->grow_count, 1);
    }
    return NULL;
}

References ao2_link, ao2_ref, ast_atomic_fetchadd_int(), d, hash_test::grow_count, ht_new(), is_timed_out(), hash_test::max_grow, NULL, and hash_test::to_be_thrashed.

Referenced by AST_TEST_DEFINE().

hash_test_lookup()

static void * hash_test_lookup ( void *  d )

static

Randomly lookup data in the hash

Definition at line 121 of file test_astobj2_thrash.c.

{
    struct hash_test *data = d;
    int max;
    unsigned seed = time(NULL);
 
    /* ast_atomic_fetchadd_int provide a memory fence so that the optimizer doesn't
     * optimize away reads.
     */
    while ((max = ast_atomic_fetchadd_int(&data->grow_count, 0)) < data->max_grow) {
        int i;
        char *obj;
        char *from_ao2;
 
        if (is_timed_out(data)) {
            return "Lookup timed out";
        }
 
        if (max == 0) {
            /* No data yet; yield and try again */
            sched_yield();
            continue;
        }
 
        /* Randomly lookup one object from the hash */
        i = rand_r(&seed) % max;
        obj = ht_new(i);
        if (obj == NULL) {
            return "Allocation failed";
        }
        from_ao2 = ao2_find(data->to_be_thrashed, obj, OBJ_POINTER);
        ao2_ref(obj, -1);
        ao2_ref(from_ao2, -1);
        if (from_ao2 == NULL) {
            return "Key unexpectedly missing";
        }
    }
 
    return NULL;
}

References ao2_find, ao2_ref, ast_atomic_fetchadd_int(), d, hash_test::grow_count, ht_new(), is_timed_out(), max, hash_test::max_grow, NULL, OBJ_POINTER, and hash_test::to_be_thrashed.

Referenced by AST_TEST_DEFINE().

hash_test_shrink()

static void * hash_test_shrink ( void *  d )

static

Delete entries from the hash

Definition at line 163 of file test_astobj2_thrash.c.

{
    const struct hash_test *data = d;
    int i;
 
    for (i = 1; i < data->preload; ++i) {
        char *obj = ht_new(-i);
        char *from_ao2;
 
        if (obj == NULL) {
            return "Allocation failed";
        }
        from_ao2 = ao2_find(data->to_be_thrashed, obj, OBJ_UNLINK | OBJ_POINTER);
 
        ao2_ref(obj, -1);
        if (from_ao2) {
            ao2_ref(from_ao2, -1);
        } else {
            return "Could not find object to delete";
        }
 
        if (is_timed_out(data)) {
            return "Shrink timed out";
        }
    }
 
    return NULL;
}

References ao2_find, ao2_ref, d, ht_new(), is_timed_out(), NULL, OBJ_POINTER, OBJ_UNLINK, hash_test::preload, and hash_test::to_be_thrashed.

Referenced by AST_TEST_DEFINE().

ht_delete()

static void ht_delete ( void *  obj )

static

Free test element.

Definition at line 77 of file test_astobj2_thrash.c.

{
    ast_atomic_fetchadd_int(&alloc_count, -1);
}

References alloc_count, and ast_atomic_fetchadd_int().

Referenced by ht_new().

ht_new()

static char * ht_new ( int  i )

static

Create test element.

Definition at line 83 of file test_astobj2_thrash.c.

{
    const int buflen = 12;
    char *keybuf = ao2_alloc(buflen, ht_delete);
    int needed;
    if (keybuf == NULL) {
        return NULL;
    }
    needed = snprintf(keybuf, buflen, "key%08x", (unsigned)i);
    ast_atomic_fetchadd_int(&alloc_count, 1);
    ast_assert(needed + 1 <= buflen);
    return keybuf;
}

References alloc_count, ao2_alloc, ast_assert, ast_atomic_fetchadd_int(), ht_delete(), and NULL.

Referenced by AST_TEST_DEFINE(), hash_test_grow(), hash_test_lookup(), and hash_test_shrink().

increment_count()

static int increment_count ( void *  obj, void *  arg, int  flags  )

static

ao2_callback for hash_test_count

Definition at line 193 of file test_astobj2_thrash.c.

                                                            {
    char *ht = obj;
    int *count = arg;
    if (strncmp(ht, "key0", 4) == 0) {
        ++(*count);
    }
    return 0;
}

Referenced by hash_test_count().

is_timed_out()

static int is_timed_out ( struct hash_test const *  data )

static

Definition at line 72 of file test_astobj2_thrash.c.

                                                      {
    return ast_tvdiff_us(data->deadline, ast_tvnow()) < 0;
}

References ast_tvdiff_us(), ast_tvnow(), and hash_test::deadline.

Referenced by hash_test_count(), hash_test_grow(), hash_test_lookup(), and hash_test_shrink().

load_module()

static int load_module ( void  )

static

Definition at line 353 of file test_astobj2_thrash.c.

{
    AST_TEST_REGISTER(hash_test);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

unload_module()

static int unload_module ( void  )

static

Definition at line 347 of file test_astobj2_thrash.c.

{
    AST_TEST_UNREGISTER(hash_test);
    return 0;
}

References AST_TEST_UNREGISTER.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "astobj2 container thrash test" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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 359 of file test_astobj2_thrash.c.

alloc_count

int alloc_count = 0

static

Definition at line 70 of file test_astobj2_thrash.c.

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

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 359 of file test_astobj2_thrash.c.