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.
static void *	hash_test_lookup (void *d)
static void *	hash_test_shrink (void *d)
static void	ht_delete (void *obj)
	Free test element.
static char *	ht_new (int i)
	Create test element.
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 = 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 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(), 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 = 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 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.