pd.if.org Git - nbds/blob - test/perf_test.c

   1 #include <stdio.h>
   2 #include <errno.h>
   3 #include <unistd.h>
   4 #include <pthread.h>
   5 #include <sys/time.h>
   6
   7 #include "common.h"
   8 #include "nstring.h"
   9 #include "runtime.h"
  10 #include "map.h"
  11 #include "rcu.h"
  12 #include "mem.h"
  13 #include "list.h"
  14 #include "skiplist.h"
  15 #include "hashtable.h"
  16
  17 //#define TEST_STRING_KEYS
  18
  19 static volatile int wait_;
  20 static volatile int stop_;
  21 static long num_threads_;
  22 static map_t *map_;
  23 static int get_range_;
  24 static int put_range_;
  25 static int num_keys_;
  26 static map_key_t *keys_ = NULL;
  27 static uint64_t times_[MAX_NUM_THREADS] = {};
  28 static int ops_[MAX_NUM_THREADS] = {};
  29
  30 void *worker (void *arg) {
  31     int tid = (int)(size_t)arg;
  32     uint64_t s = nbd_rand_seed(tid);
  33     int get_ops = 0, put_ops = 0, del_ops = 0;
  34
  35     // Wait for all the worker threads to be ready.
  36     (void)SYNC_ADD(&wait_, -1);
  37     do {} while (wait_);
  38
  39     uint64_t t1 = rdtsc();
  40
  41     while (!stop_) {
  42         int r = nbd_next_rand(&s);
  43         int x = r & ( (1 << 20) - 1 );
  44         int i = nbd_next_rand(&s) & (num_keys_ - 1);
  45         map_key_t key = keys_[i];
  46         if (x < get_range_) {
  47             map_val_t val = map_get(map_, key);
  48 #ifdef TEST_STRING_KEYS
  49             ASSERT(val == DOES_NOT_EXIST || ns_cmp((nstring_t *)key, (nstring_t *)val) == 0);
  50 #else
  51             ASSERT(val == DOES_NOT_EXIST || key == val);
  52 #endif
  53             get_ops++;
  54         } else if (x < put_range_) {
  55             map_add(map_, key, key);
  56             put_ops++;
  57         } else {
  58             map_remove(map_, key);
  59             del_ops++;
  60         }
  61         rcu_update();
  62     }
  63
  64     times_[tid] = rdtsc() - t1;
  65     ops_[tid] = get_ops + put_ops + del_ops;
  66
  67     return NULL;
  68 }
  69
  70 void run_test (void) {
  71     wait_ = num_threads_ + 1;
  72
  73     // Quicky sanity check
  74     int n = 100;
  75     if (num_keys_ < n) { n = num_keys_; }
  76     for (int i = 0; i < n; ++i) {
  77         map_set(map_, keys_[i], keys_[i]);
  78         for(int j = 0; j < i; ++j) {
  79 #ifdef TEST_STRING_KEYS
  80             ASSERT(ns_cmp((nstring_t *)map_get(map_, keys_[i]), (nstring_t *)keys_[i]) == 0);
  81 #else
  82             ASSERT(map_get(map_, keys_[i]) == keys_[i]);
  83 #endif
  84         }
  85     }
  86
  87     stop_ = 0;
  88
  89     pthread_t thread[MAX_NUM_THREADS];
  90     for (int i = 0; i < num_threads_; ++i) {
  91         int rc = nbd_thread_create(thread + i, i, worker, (void*)(size_t)i);
  92         if (rc != 0) { perror("pthread_create"); exit(rc); }
  93     }
  94
  95     do { /* nothing */ } while (wait_ != 1);
  96
  97     wait_ = 0;
  98     sleep(2);
  99     stop_ = 1;
 100
 101     for (int i = 0; i < num_threads_; ++i) {
 102         pthread_join(thread[i], NULL);
 103     }
 104 }
 105
 106 int main (int argc, char **argv) {
 107     char* program_name = argv[0];
 108
 109     if (argc > 2) {
 110         fprintf(stderr, "Usage: %s num_threads\n", program_name);
 111         return -1;
 112     }
 113
 114     num_threads_ = 2;
 115     if (argc == 2)
 116     {
 117         errno = 0;
 118         num_threads_ = strtol(argv[1], NULL, 10);
 119         if (errno) {
 120             fprintf(stderr, "%s: Invalid argument for number of threads\n", program_name);
 121             return -1;
 122         }
 123         if (num_threads_ <= 0) {
 124             fprintf(stderr, "%s: Number of threads must be at least 1\n", program_name);
 125             return -1;
 126         }
 127         if (num_threads_ > MAX_NUM_THREADS) {
 128             fprintf(stderr, "%s: Number of threads cannot be more than %d\n", program_name, MAX_NUM_THREADS);
 129             return -1;
 130         }
 131     }
 132
 133
 134     int table_scale = 10;
 135     int read_ratio = 95;
 136     get_range_ = (read_ratio << 20) / 100;
 137     put_range_ = (((1 << 20) - get_range_) >> 1) + get_range_;
 138
 139     static const map_impl_t *map_types[] = { &MAP_IMPL_HT };
 140     for (int i = 0; i < sizeof(map_types)/sizeof(*map_types); ++i) {
 141 #ifdef TEST_STRING_KEYS
 142         map_ = map_alloc(map_types[i], &DATATYPE_NSTRING);
 143 #else
 144         map_ = map_alloc(map_types[i], NULL);
 145 #endif
 146
 147         // Do some warmup
 148         num_keys_ = 1 << table_scale;
 149         keys_ = nbd_malloc(sizeof(map_key_t) * num_keys_);
 150         for (int j = 0; j < num_keys_; ++j) {
 151 #ifdef TEST_STRING_KEYS
 152             char tmp[64];
 153             snprintf(tmp, sizeof(tmp), "%dabc%d", j, j*17+123);
 154             int n = strlen(tmp);
 155             keys_[j] = ns_alloc(n);
 156             memcpy(keys_[j], tmp, n);
 157 #else
 158             keys_[j] = j*17+123;
 159 #endif
 160         }
 161
 162         struct timeval tv1, tv2;
 163         gettimeofday(&tv1, NULL);
 164
 165         int num_trials = 1;
 166         for (int i = 0; i < num_trials; ++i) {
 167             run_test();
 168         }
 169
 170         gettimeofday(&tv2, NULL);
 171         int ms = (int)(1000000*(tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec - tv1.tv_usec) / 1000;
 172         map_print(map_);
 173         printf("Th:%ld Time:%dms\n\n", num_threads_, ms);
 174         fflush(stdout);
 175
 176         map_free(map_);
 177     }
 178
 179     return 0;
 180 }