git.m6w6.name Git - awesomized/libmemcached/blob - tests/atomsmasher.c

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <unistd.h>
  13 #include <time.h>
  14 #include "server.h"
  15 #include "../lib/common.h"
  16 #include "../src/generator.h"
  17 #include "../src/execute.h"
  18
  19 #ifndef INT64_MAX
  20 #define INT64_MAX LONG_MAX
  21 #endif
  22 #ifndef INT32_MAX
  23 #define INT32_MAX INT_MAX
  24 #endif
  25
  26
  27 #include "test.h"
  28
  29 /* Number of items generated for tests */
  30 #define GLOBAL_COUNT 100000
  31
  32 /* Number of times to run the test loop */
  33 #define TEST_COUNTER 500000
  34 static uint32_t global_count;
  35
  36 static pairs_st *global_pairs;
  37 static char *global_keys[GLOBAL_COUNT];
  38 static size_t global_keys_length[GLOBAL_COUNT];
  39
  40 uint8_t cleanup_pairs(memcached_st *memc)
  41 {
  42   pairs_free(global_pairs);
  43
  44   return 0;
  45 }
  46
  47 uint8_t generate_pairs(memcached_st *memc)
  48 {
  49   unsigned long long x;
  50   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
  51   global_count= GLOBAL_COUNT;
  52
  53   for (x= 0; x < global_count; x++)
  54   {
  55     global_keys[x]= global_pairs[x].key;
  56     global_keys_length[x]=  global_pairs[x].key_length;
  57   }
  58
  59   return 0;
  60 }
  61
  62 uint8_t drizzle(memcached_st *memc)
  63 {
  64   unsigned int x;
  65   memcached_return rc;
  66   char *return_value;
  67   size_t return_value_length;
  68   uint32_t flags;
  69
  70 infinite:
  71   for (x= 0; x < TEST_COUNTER; x++)
  72   {
  73     uint32_t test_bit;
  74     uint8_t which;
  75
  76     test_bit= random() % GLOBAL_COUNT;
  77     which= random() % 2;
  78
  79     if (which == 0)
  80     {
  81       return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit],
  82                                   &return_value_length, &flags, &rc);
  83       if (rc == MEMCACHED_SUCCESS && return_value)
  84         free(return_value);
  85       else if (rc == MEMCACHED_NOTFOUND)
  86         continue;
  87       else
  88       {
  89         WATCHPOINT_ERROR(rc);
  90         WATCHPOINT_ASSERT(rc);
  91       }
  92     }
  93     else
  94     {
  95       rc= memcached_set(memc, global_pairs[test_bit].key,
  96                         global_pairs[test_bit].key_length,
  97                         global_pairs[test_bit].value,
  98                         global_pairs[test_bit].value_length,
  99                         0, 0);
 100       if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
 101       {
 102         WATCHPOINT_ERROR(rc);
 103         WATCHPOINT_ASSERT(0);
 104       }
 105     }
 106   }
 107
 108   if (getenv("MEMCACHED_ATOM_BURIN_IN"))
 109     goto infinite;
 110
 111   return 0;
 112 }
 113
 114 memcached_return pre_nonblock(memcached_st *memc)
 115 {
 116   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 117
 118   return MEMCACHED_SUCCESS;
 119 }
 120
 121 memcached_return pre_md5(memcached_st *memc)
 122 {
 123   memcached_hash value= MEMCACHED_HASH_MD5;
 124   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
 125
 126   return MEMCACHED_SUCCESS;
 127 }
 128
 129 memcached_return pre_hsieh(memcached_st *memc)
 130 {
 131   memcached_hash value= MEMCACHED_HASH_HSIEH;
 132   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
 133
 134   return MEMCACHED_SUCCESS;
 135 }
 136
 137 memcached_return enable_consistent(memcached_st *memc)
 138 {
 139   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
 140   memcached_hash hash;
 141   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
 142   pre_hsieh(memc);
 143
 144   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
 145   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
 146
 147   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 148   assert(hash == MEMCACHED_HASH_HSIEH);
 149
 150
 151   return MEMCACHED_SUCCESS;
 152 }
 153
 154 test_st smash_tests[] ={
 155   {"generate_pairs", 1, generate_pairs },
 156   {"drizzle", 1, drizzle },
 157   {"cleanup", 1, cleanup_pairs },
 158   {0, 0, 0}
 159 };
 160
 161
 162 collection_st collection[] ={
 163   {"smash", 0, 0, smash_tests},
 164   {"smash_hsieh", pre_hsieh, 0, smash_tests},
 165   {"smash_hsieh_consistent", enable_consistent, 0, smash_tests},
 166   {"smash_md5", pre_md5, 0, smash_tests},
 167   {"smash_nonblock", pre_nonblock, 0, smash_tests},
 168   {0, 0, 0, 0}
 169 };
 170
 171 #define SERVERS_TO_CREATE 5
 172
 173 void *world_create(void)
 174 {
 175   server_startup_st *construct;
 176
 177   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
 178   memset(construct, 0, sizeof(server_startup_st));
 179   construct->count= SERVERS_TO_CREATE;
 180   construct->udp= 0;
 181   server_startup(construct);
 182
 183   return construct;
 184 }
 185
 186 void world_destroy(void *p)
 187 {
 188   server_startup_st *construct= (server_startup_st *)p;
 189   memcached_server_st *servers= (memcached_server_st *)construct->servers;
 190   memcached_server_list_free(servers);
 191
 192   server_shutdown(construct);
 193   free(construct);
 194 }
 195
 196 void get_world(world_st *world)
 197 {
 198   world->collections= collection;
 199   world->create= world_create;
 200   world->destroy= world_destroy;
 201 }