lib/tdb/tools/tdbtest.c

   1 /* a test program for tdb - the trivial database */
   2
   3 #include "replace.h"
   4 #include "tdb.h"
   5 #include "system/filesys.h"
   6 #include "system/time.h"
   7
   8 #include <gdbm.h>
   9
  10
  11 #define DELETE_PROB 7
  12 #define STORE_PROB 5
  13
  14 static struct tdb_context *db;
  15 static GDBM_FILE gdbm;
  16
  17 struct timeval tp1,tp2;
  18
  19 static void _start_timer(void)
  20 {
  21         gettimeofday(&tp1,NULL);
  22 }
  23
  24 static double _end_timer(void)
  25 {
  26         gettimeofday(&tp2,NULL);
  27         return((tp2.tv_sec - tp1.tv_sec) +
  28                (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
  29 }
  30
  31 static void fatal(const char *why)
  32 {
  33         perror(why);
  34         exit(1);
  35 }
  36
  37 #ifdef PRINTF_ATTRIBUTE
  38 static void tdb_log(struct tdb_context *tdb, int level, const char *format, ...) PRINTF_ATTRIBUTE(3,4);
  39 #endif
  40 static void tdb_log(struct tdb_context *tdb, int level, const char *format, ...)
  41 {
  42         va_list ap;
  43
  44         va_start(ap, format);
  45         vfprintf(stdout, format, ap);
  46         va_end(ap);
  47         fflush(stdout);
  48 }
  49
  50 static void compare_db(void)
  51 {
  52         TDB_DATA d, key, nextkey;
  53         datum gd, gkey, gnextkey;
  54
  55         key = tdb_firstkey(db);
  56         while (key.dptr) {
  57                 d = tdb_fetch(db, key);
  58                 gkey.dptr = key.dptr;
  59                 gkey.dsize = key.dsize;
  60
  61                 gd = gdbm_fetch(gdbm, gkey);
  62
  63                 if (!gd.dptr) fatal("key not in gdbm");
  64                 if (gd.dsize != d.dsize) fatal("data sizes differ");
  65                 if (memcmp(gd.dptr, d.dptr, d.dsize)) {
  66                         fatal("data differs");
  67                 }
  68
  69                 nextkey = tdb_nextkey(db, key);
  70                 free(key.dptr);
  71                 free(d.dptr);
  72                 free(gd.dptr);
  73                 key = nextkey;
  74         }
  75
  76         gkey = gdbm_firstkey(gdbm);
  77         while (gkey.dptr) {
  78                 gd = gdbm_fetch(gdbm, gkey);
  79                 key.dptr = gkey.dptr;
  80                 key.dsize = gkey.dsize;
  81
  82                 d = tdb_fetch(db, key);
  83
  84                 if (!d.dptr) fatal("key not in db");
  85                 if (d.dsize != gd.dsize) fatal("data sizes differ");
  86                 if (memcmp(d.dptr, gd.dptr, gd.dsize)) {
  87                         fatal("data differs");
  88                 }
  89
  90                 gnextkey = gdbm_nextkey(gdbm, gkey);
  91                 free(gkey.dptr);
  92                 free(gd.dptr);
  93                 free(d.dptr);
  94                 gkey = gnextkey;
  95         }
  96 }
  97
  98 static char *randbuf(int len)
  99 {
 100         char *buf;
 101         int i;
 102         buf = (char *)malloc(len+1);
 103
 104         for (i=0;i<len;i++) {
 105                 buf[i] = 'a' + (rand() % 26);
 106         }
 107         buf[i] = 0;
 108         return buf;
 109 }
 110
 111 static void addrec_db(void)
 112 {
 113         int klen, dlen;
 114         char *k, *d;
 115         TDB_DATA key, data;
 116
 117         klen = 1 + (rand() % 4);
 118         dlen = 1 + (rand() % 100);
 119
 120         k = randbuf(klen);
 121         d = randbuf(dlen);
 122
 123         key.dptr = k;
 124         key.dsize = klen+1;
 125
 126         data.dptr = d;
 127         data.dsize = dlen+1;
 128
 129         if (rand() % DELETE_PROB == 0) {
 130                 tdb_delete(db, key);
 131         } else if (rand() % STORE_PROB == 0) {
 132                 if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
 133                         fatal("tdb_store failed");
 134                 }
 135         } else {
 136                 data = tdb_fetch(db, key);
 137                 if (data.dptr) free(data.dptr);
 138         }
 139
 140         free(k);
 141         free(d);
 142 }
 143
 144 static void addrec_gdbm(void)
 145 {
 146         int klen, dlen;
 147         char *k, *d;
 148         datum key, data;
 149
 150         klen = 1 + (rand() % 4);
 151         dlen = 1 + (rand() % 100);
 152
 153         k = randbuf(klen);
 154         d = randbuf(dlen);
 155
 156         key.dptr = k;
 157         key.dsize = klen+1;
 158
 159         data.dptr = d;
 160         data.dsize = dlen+1;
 161
 162         if (rand() % DELETE_PROB == 0) {
 163                 gdbm_delete(gdbm, key);
 164         } else if (rand() % STORE_PROB == 0) {
 165                 if (gdbm_store(gdbm, key, data, GDBM_REPLACE) != 0) {
 166                         fatal("gdbm_store failed");
 167                 }
 168         } else {
 169                 data = gdbm_fetch(gdbm, key);
 170                 if (data.dptr) free(data.dptr);
 171         }
 172
 173         free(k);
 174         free(d);
 175 }
 176
 177 static int traverse_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
 178 {
 179 #if 0
 180         printf("[%s] [%s]\n", key.dptr, dbuf.dptr);
 181 #endif
 182         tdb_delete(tdb, key);
 183         return 0;
 184 }
 185
 186 static void merge_test(void)
 187 {
 188         int i;
 189         char keys[5][2];
 190         char tdata[] = "test";
 191         TDB_DATA key, data;
 192
 193         for (i = 0; i < 5; i++) {
 194                 snprintf(keys[i],2, "%d", i);
 195                 key.dptr = keys[i];
 196                 key.dsize = 2;
 197
 198                 data.dptr = tdata;
 199                 data.dsize = 4;
 200
 201                 if (tdb_store(db, key, data, TDB_REPLACE) != 0) {
 202                         fatal("tdb_store failed");
 203                 }
 204         }
 205
 206         key.dptr = keys[0];
 207         tdb_delete(db, key);
 208         key.dptr = keys[4];
 209         tdb_delete(db, key);
 210         key.dptr = keys[2];
 211         tdb_delete(db, key);
 212         key.dptr = keys[1];
 213         tdb_delete(db, key);
 214         key.dptr = keys[3];
 215         tdb_delete(db, key);
 216 }
 217
 218 static char *test_path(const char *filename)
 219 {
 220         const char *prefix = getenv("TEST_DATA_PREFIX");
 221
 222         if (prefix) {
 223                 char *path = NULL;
 224                 int ret;
 225
 226                 ret = asprintf(&path, "%s/%s", prefix, filename);
 227                 if (ret == -1) {
 228                         return NULL;
 229                 }
 230                 return path;
 231         }
 232
 233         return strdup(filename);
 234 }
 235
 236  int main(int argc, const char *argv[])
 237 {
 238         int i, seed=0;
 239         int loops = 10000;
 240         int num_entries;
 241         char test_gdbm[1] = "test.gdbm";
 242         char *test_tdb;
 243
 244         test_gdbm[0] = test_path("test.gdbm");
 245         test_tdb = test_path("test.tdb");
 246
 247         unlink(test_gdbm[0]);
 248
 249         db = tdb_open(test_tdb, 0, TDB_CLEAR_IF_FIRST,
 250                       O_RDWR | O_CREAT | O_TRUNC, 0600);
 251         gdbm = gdbm_open(test_gdbm, 512, GDBM_WRITER|GDBM_NEWDB|GDBM_FAST,
 252                          0600, NULL);
 253
 254         if (!db || !gdbm) {
 255                 fatal("db open failed");
 256         }
 257
 258 #if 1
 259         srand(seed);
 260         _start_timer();
 261         for (i=0;i<loops;i++) addrec_gdbm();
 262         printf("gdbm got %.2f ops/sec\n", i/_end_timer());
 263 #endif
 264
 265         merge_test();
 266
 267         srand(seed);
 268         _start_timer();
 269         for (i=0;i<loops;i++) addrec_db();
 270         printf("tdb got %.2f ops/sec\n", i/_end_timer());
 271
 272         if (tdb_validate_freelist(db, &num_entries) == -1) {
 273                 printf("tdb freelist is corrupt\n");
 274         } else {
 275                 printf("tdb freelist is good (%d entries)\n", num_entries);
 276         }
 277
 278         compare_db();
 279
 280         printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
 281         printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
 282
 283         tdb_close(db);
 284         gdbm_close(gdbm);
 285
 286         free(test_gdbm[0]);
 287         free(test_tdb);
 288
 289         return 0;
 290 }