Skip to content

Commit

Permalink
Update DBM bulk operation benchmark programs
Browse files Browse the repository at this point in the history
  • Loading branch information
@mita
mita committed Nov 2, 2010
1 parent e9f69de commit 94be684
Show file tree
Hide file tree
Showing 4 changed files with 545 additions and 149 deletions.
32 changes: 18 additions & 14 deletions berkeleydbtest.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -164,9 +164,10 @@ static char *command = "";
static char *path = "data";
static int num = 5000000;
static int vsiz = 100;
static long seed;
static unsigned int seed;
static int batch = 1000;
static int thnum = 1;
static bool debug = false;

static void parse_options(int argc, char **argv)
{
Expand All @@ -182,7 +183,7 @@ static void parse_options(int argc, char **argv)
} else if (!strcmp(argv[i], "-vsiz")) {
vsiz = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-seed")) {
seed = atol(argv[++i]);
seed = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-batch")) {
batch = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-thnum")) {
Expand All @@ -191,13 +192,15 @@ static void parse_options(int argc, char **argv)
die("Invalid -thnum option");
} else if (!strcmp(argv[i], "-key")) {
keygen_set_generator(argv[++i]);
} else if (!strcmp(argv[i], "-debug")) {
debug = true;
} else {
die("Invalid command option");
}
}
}

#define KSIZ sizeof("0x0000000000000000-0x0000000000000000")
#define KSIZ KEYGEN_KEY_SIZE

static void db_put(DB *db, DBT *key, DBT *data, u_int32_t flags)
{
Expand All @@ -217,14 +220,16 @@ static void db_put(DB *db, DBT *key, DBT *data, u_int32_t flags)
}
}

static void putlist_test(DB *db, int num, int vsiz, long seed)
static void putlist_test(DB *db, int num, int vsiz, unsigned int seed)
{
struct keygen *keygen = keygen_alloc(seed);
struct keygen keygen;
char *value = xmalloc(vsiz);
DBT key, data;
void *ptrk, *ptrd;
int i;

keygen_init(&keygen, seed);

memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));

Expand All @@ -241,7 +246,7 @@ static void putlist_test(DB *db, int num, int vsiz, long seed)

for (i = 0; i < num; i++) {
DB_MULTIPLE_WRITE_NEXT(ptrk, &key,
keygen_next_key(keygen), KSIZ);
keygen_next_key(&keygen), KSIZ);
DB_MULTIPLE_WRITE_NEXT(ptrd, &data, value, vsiz);
if (ptrk == NULL || ptrd == NULL)
die("DB_MULTIPLE_WRITE_NEXT failed");
Expand Down Expand Up @@ -275,7 +280,6 @@ static void putlist_test(DB *db, int num, int vsiz, long seed)
}

free(value);
keygen_free(keygen);
}

static void db_del(DB *db, DBT *key, u_int32_t flags)
Expand All @@ -296,13 +300,15 @@ static void db_del(DB *db, DBT *key, u_int32_t flags)
}
}

static void outlist_test(DB *db, int num, long seed)
static void outlist_test(DB *db, int num, unsigned int seed)
{
struct keygen *keygen = keygen_alloc(seed);
struct keygen keygen;
DBT key;
void *ptrk;
int i;

keygen_init(&keygen, seed);

memset(&key, 0, sizeof(key));

key.ulen = batch * KSIZ * 1024;
Expand All @@ -313,7 +319,7 @@ static void outlist_test(DB *db, int num, long seed)

for (i = 0; i < num; i++) {
DB_MULTIPLE_WRITE_NEXT(ptrk, &key,
keygen_next_key(keygen), KSIZ);
keygen_next_key(&keygen), KSIZ);
if (ptrk == NULL)
die("DB_MULTIPLE_WRITE_NEXT failed");

Expand All @@ -335,15 +341,13 @@ static void outlist_test(DB *db, int num, long seed)
db_del(db, &key, DB_MULTIPLE);
free(key.data);
}

keygen_free(keygen);
}

struct thread_data {
pthread_t tid;
pthread_barrier_t *barrier;
DB *db;
long seed;
unsigned int seed;
unsigned long long elapsed;
};

Expand All @@ -352,7 +356,7 @@ static void *benchmark_thread(void *arg)
struct thread_data *data = arg;
unsigned long long start;
DB *db = data->db;
long seed = data->seed;
unsigned int seed = data->seed;

pthread_barrier_wait(data->barrier);

Expand Down
89 changes: 31 additions & 58 deletions testutil.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,73 +43,54 @@ static void xpthread_join(pthread_t th)
die("pthread_join failed");
}

struct keygen {
long seed;
char *(*next_key)(struct keygen *keygen);
void *data;
};
#define KEYGEN_KEY_SIZE sizeof("0x0000000000000000-0x0000000000000000")
#define KEYGEN_PREFIX_SIZE (sizeof("0x0000000000000000-") - 1)

struct keygen_sequence {
char key[sizeof("0x0000000000000000-0x0000000000000000")];
unsigned long long counter;
struct keygen {
unsigned int prefix;
char key[KEYGEN_KEY_SIZE];
unsigned int (*next)(unsigned int *state);
unsigned int seed;
};

static char *keygen_sequence_next_key(struct keygen *keygen)
static unsigned int keygen_sequence_next(unsigned int *seed)
{
struct keygen_sequence *keygen_data = keygen->data;

sprintf(keygen_data->key, "0x%016llx-0x%016llx",
(unsigned long long) keygen->seed,
keygen_data->counter++);

return keygen_data->key;
return (*seed)++;
}

static void keygen_sequence_init(struct keygen *keygen, long seed)
static void keygen_sequence_init(struct keygen *keygen, unsigned int seed)
{
struct keygen_sequence *keygen_data = xmalloc(sizeof(*keygen_data));

keygen->seed = seed;
keygen->next_key = keygen_sequence_next_key;
keygen->data = keygen_data;

keygen_data->counter = 0;
keygen->next = keygen_sequence_next;
keygen->seed = 0;
}

struct keygen_random {
char key[sizeof("0x0000000000000000-0x0000000000000000")];
unsigned int seed;
};

static char *keygen_random_next_key(struct keygen *keygen)
static unsigned int keygen_random_next(unsigned int *seed)
{
struct keygen_random *keygen_data = keygen->data;
unsigned long long random;

random = rand_r(&keygen_data->seed);
random *= RAND_MAX;
random += rand_r(&keygen_data->seed);

sprintf(keygen_data->key, "0x%016llx-0x%016llx",
(unsigned long long)keygen->seed, random);
return (unsigned int) rand_r(seed);
}

return keygen_data->key;
static void keygen_random_init(struct keygen *keygen, unsigned int seed)
{
keygen->next = keygen_random_next;
keygen->seed = seed;
}

static void keygen_random_init(struct keygen *keygen, long seed)
static char *keygen_next_key(struct keygen *keygen)
{
struct keygen_random *keygen_data = xmalloc(sizeof(*keygen_data));
unsigned int next = keygen->next(&keygen->seed);

keygen->seed = seed;
keygen->next_key = keygen_random_next_key;
keygen->data = keygen_data;
sprintf(keygen->key, "0x%016llx-0x%016llx",
(unsigned long long)keygen->prefix,
(unsigned long long)next);

keygen_data->seed = seed;
return keygen->key;
}

static char *keygen_next_key(struct keygen *keygen)
static inline char *keygen_prefix(struct keygen *keygen, char *buf)
{
return keygen->next_key(keygen);
sprintf(buf, "0x%016llx-", (unsigned long long)keygen->prefix);

return buf;
}

static const char *key_generator = "sequence";
Expand All @@ -119,22 +100,14 @@ static void keygen_set_generator(const char *generator)
key_generator = generator;
}

static void *keygen_alloc(long seed)
static void keygen_init(struct keygen *keygen, unsigned int seed)
{
struct keygen *keygen = xmalloc(sizeof(*keygen));
keygen->prefix = seed;

if (!strcmp(key_generator, "random"))
keygen_random_init(keygen, seed);
else
keygen_sequence_init(keygen, seed);

return keygen;
}

static void keygen_free(struct keygen *keygen)
{
free(keygen->data);
free(keygen);
}

static unsigned long long tv_to_us(const struct timeval *tv)
Expand Down
Loading

0 comments on commit 94be684

Please sign in to comment.