X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=tests%2Fatomsmasher.c;h=afdf0830782bb3c4468a3073cbf157c991616d7e;hb=86be0943416087ba738c28ddbde8cdcbd62ad777;hp=abe3a21e9cec52ab99e7d868ff099a5f7cba2a33;hpb=beda55e1f1e2cba7e647e2dea4c86f536052f2cb;p=m6w6%2Flibmemcached diff --git a/tests/atomsmasher.c b/tests/atomsmasher.c index abe3a21e..afdf0830 100644 --- a/tests/atomsmasher.c +++ b/tests/atomsmasher.c @@ -1,30 +1,36 @@ +/* LibMemcached + * Copyright (C) 2006-2009 Brian Aker + * All rights reserved. + * + * Use and distribution licensed under the BSD license. See + * the COPYING file in the parent directory for full text. + * + * Summary: + * + */ + /* Sample test application. */ -#include -#include +#include "config.h" + +#include "libmemcached/memcached.h" +#include "libmemcached/watchpoint.h" + #include #include +#include #include #include #include #include #include #include -#include "server.h" -#include "../lib/common.h" -#include "../src/generator.h" -#include "../src/execute.h" - -#ifndef INT64_MAX -#define INT64_MAX LONG_MAX -#endif -#ifndef INT32_MAX -#define INT32_MAX INT_MAX -#endif +#include "../clients/generator.h" +#include "../clients/execute.h" - -#include "test.h" +#include +#include /* Number of items generated for tests */ #define GLOBAL_COUNT 100000 @@ -37,64 +43,68 @@ static pairs_st *global_pairs; static char *global_keys[GLOBAL_COUNT]; static size_t global_keys_length[GLOBAL_COUNT]; -uint8_t cleanup_pairs(memcached_st *memc) +static test_return_t cleanup_pairs(memcached_st *memc) { + (void)memc; pairs_free(global_pairs); - return 0; + return EXIT_SUCCESS; } -uint8_t generate_pairs(memcached_st *memc) +static test_return_t generate_pairs(memcached_st *memc) { - unsigned long long x; + (void)memc; global_pairs= pairs_generate(GLOBAL_COUNT, 400); global_count= GLOBAL_COUNT; - for (x= 0; x < global_count; x++) + for (size_t x= 0; x < global_count; x++) { - global_keys[x]= global_pairs[x].key; + global_keys[x]= global_pairs[x].key; global_keys_length[x]= global_pairs[x].key_length; } - return 0; + return EXIT_SUCCESS; } -uint8_t drizzle(memcached_st *memc) +static test_return_t drizzle(memcached_st *memc) { - unsigned int x; - memcached_return rc; + memcached_return_t rc; char *return_value; size_t return_value_length; uint32_t flags; infinite: - for (x= 0; x < TEST_COUNTER; x++) + for (size_t x= 0; x < TEST_COUNTER; x++) { uint32_t test_bit; uint8_t which; - test_bit= random() % GLOBAL_COUNT; - which= random() % 2; + test_bit= (uint32_t)(random() % GLOBAL_COUNT); + which= (uint8_t)(random() % 2); if (which == 0) { return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit], &return_value_length, &flags, &rc); if (rc == MEMCACHED_SUCCESS && return_value) + { free(return_value); + } else if (rc == MEMCACHED_NOTFOUND) + { continue; + } else { WATCHPOINT_ERROR(rc); WATCHPOINT_ASSERT(rc); } - } + } else { - rc= memcached_set(memc, global_pairs[test_bit].key, + rc= memcached_set(memc, global_pairs[test_bit].key, global_pairs[test_bit].key_length, - global_pairs[test_bit].value, + global_pairs[test_bit].value, global_pairs[test_bit].value_length, 0, 0); if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED) @@ -108,94 +118,179 @@ infinite: if (getenv("MEMCACHED_ATOM_BURIN_IN")) goto infinite; - return 0; + return TEST_SUCCESS; } -memcached_return pre_nonblock(memcached_st *memc) +static test_return_t pre_nonblock(memcached_st *memc) +{ + memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0); + + return TEST_SUCCESS; +} + +/* + Set the value, then quit to make sure it is flushed. + Come back in and test that add fails. +*/ +static test_return_t add_test(memcached_st *memc) { - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL); + memcached_return_t rc; + const char *key= "foo"; + const char *value= "when we sanitize"; + unsigned long long setting_value; + + setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK); + + rc= memcached_set(memc, key, strlen(key), + value, strlen(value), + (time_t)0, (uint32_t)0); + test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); + memcached_quit(memc); + rc= memcached_add(memc, key, strlen(key), + value, strlen(value), + (time_t)0, (uint32_t)0); + + /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */ + if (setting_value) + { + test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED); + } + else + { + test_true(rc == MEMCACHED_NOTSTORED); + } - return MEMCACHED_SUCCESS; + return EXIT_SUCCESS; } -memcached_return pre_md5(memcached_st *memc) +/* + * repeating add_tests many times + * may show a problem in timing + */ +static test_return_t many_adds(memcached_st *memc) +{ + for (size_t x= 0; x < TEST_COUNTER; x++) + { + add_test(memc); + } + return EXIT_SUCCESS; +} + +test_st smash_tests[] ={ + {"generate_pairs", 1, (test_callback_fn)generate_pairs }, + {"drizzle", 1, (test_callback_fn)drizzle }, + {"cleanup", 1, (test_callback_fn)cleanup_pairs }, + {"many_adds", 1, (test_callback_fn)many_adds }, + {0, 0, 0} +}; + +#define BENCHMARK_TEST_LOOP 20000 + +struct benchmark_state_st +{ + bool create_init; + bool clone_init; + memcached_st *create; + memcached_st *clone; +} benchmark_state; + +static test_return_t memcached_create_benchmark(memcached_st *memc) { - memcached_hash value= MEMCACHED_HASH_MD5; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + (void)memc; + benchmark_state.create_init= true; + + for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + { + memcached_st *ptr; + ptr= memcached_create(&benchmark_state.create[x]); + + test_true(ptr); + } - return MEMCACHED_SUCCESS; + return TEST_SUCCESS; } -memcached_return pre_hsieh(memcached_st *memc) +static test_return_t memcached_clone_benchmark(memcached_st *memc) { - memcached_hash value= MEMCACHED_HASH_HSIEH; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value); + benchmark_state.clone_init= true; - return MEMCACHED_SUCCESS; + for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + { + memcached_st *ptr; + ptr= memcached_clone(&benchmark_state.clone[x], memc); + + test_true(ptr); + } + + return TEST_SUCCESS; } -memcached_return enable_consistent(memcached_st *memc) +static test_return_t pre_allocate(memcached_st *memc) { - memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT; - memcached_hash hash; - memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value); - pre_hsieh(memc); + (void)memc; + memset(&benchmark_state, 0, sizeof(benchmark_state)); + + benchmark_state.create= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); + test_true(benchmark_state.create); + benchmark_state.clone= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st)); + test_true(benchmark_state.clone); - value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION); - assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT); + return TEST_SUCCESS; +} + +static test_return_t post_allocate(memcached_st *memc) +{ + (void)memc; + for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++) + { + if (benchmark_state.create_init) + memcached_free(&benchmark_state.create[x]); - hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH); - assert(hash == MEMCACHED_HASH_HSIEH); + if (benchmark_state.clone_init) + memcached_free(&benchmark_state.clone[x]); + } + free(benchmark_state.create); + free(benchmark_state.clone); - return MEMCACHED_SUCCESS; + return TEST_SUCCESS; } -test_st smash_tests[] ={ - {"generate_pairs", 1, generate_pairs }, - {"drizzle", 1, drizzle }, - {"cleanup", 1, cleanup_pairs }, + +test_st micro_tests[] ={ + {"memcached_create", 1, (test_callback_fn)memcached_create_benchmark }, + {"memcached_clone", 1, (test_callback_fn)memcached_clone_benchmark }, {0, 0, 0} }; collection_st collection[] ={ {"smash", 0, 0, smash_tests}, - {"smash_hsieh", pre_hsieh, 0, smash_tests}, - {"smash_hsieh_consistent", enable_consistent, 0, smash_tests}, - {"smash_md5", pre_md5, 0, smash_tests}, - {"smash_nonblock", pre_nonblock, 0, smash_tests}, + {"smash_nonblock", (test_callback_fn)pre_nonblock, 0, smash_tests}, + {"micro-benchmark", (test_callback_fn)pre_allocate, (test_callback_fn)post_allocate, micro_tests}, {0, 0, 0, 0} }; + #define SERVERS_TO_CREATE 5 -void *world_create(void) -{ - server_startup_st *construct; +#include "libmemcached_world.h" - construct= (server_startup_st *)malloc(sizeof(server_startup_st)); - memset(construct, 0, sizeof(server_startup_st)); - construct->count= SERVERS_TO_CREATE; - construct->udp= 0; - server_startup(construct); +void get_world(world_st *world) +{ + world->collections= collection; - return construct; -} + world->create= (test_callback_create_fn)world_create; + world->destroy= (test_callback_fn)world_destroy; -void world_destroy(void *p) -{ - server_startup_st *construct= (server_startup_st *)p; - memcached_server_st *servers= (memcached_server_st *)construct->servers; - memcached_server_list_free(servers); + world->test.startup= (test_callback_fn)world_test_startup; + world->test.flush= (test_callback_fn)world_flush; + world->test.pre_run= (test_callback_fn)world_pre_run; + world->test.post_run= (test_callback_fn)world_post_run; + world->test.on_error= (test_callback_error_fn)world_on_error; - server_shutdown(construct); - free(construct); -} + world->collection.startup= (test_callback_fn)world_container_startup; + world->collection.shutdown= (test_callback_fn)world_container_shutdown; -void get_world(world_st *world) -{ - world->collections= collection; - world->create= world_create; - world->destroy= world_destroy; + world->runner= &defualt_libmemcached_runner; }