Start working on examples. [t:1904]

git-svn-id: file:///svn/toku/tokudb@13636 c7de825b-a66e-492c-adef-691d508d4ae1

release/examples/db-insert/Makefile

+default: db-insert

release/examples/db-insert/db-insert.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+#ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
+
+/* Insert a bunch of stuff */
+#include <db.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#if !defined(DB_YESOVERWRITE)
+#define DB_YESOVERWRITE 0
+#endif
+
+#if !defined(DB_PRELOCKED_WRITE)
+#define NO_DB_PRELOCKED
+#define DB_PRELOCKED_WRITE 0
+#endif
+
+int verbose=1;
+
+enum { SERIAL_SPACING = 1<<6 };
+enum { DEFAULT_ITEMS_TO_INSERT_PER_ITERATION = 1<<20 };
+enum { DEFAULT_ITEMS_PER_TRANSACTION = 1<<14 };
+
+static void insert (long long v);
+#define CKERR(r) if (r!=0) fprintf(stderr, "%s:%d error %d %s\n", __FILE__, __LINE__, r, db_strerror(r)); assert(r==0);
+#define CKERR2(r,rexpect) if (r!=rexpect) fprintf(stderr, "%s:%d error %d %s\n", __FILE__, __LINE__, r, db_strerror(r)); assert(r==rexpect);
+
+/* default test parameters */
+int keysize = sizeof (long long);
+int valsize = sizeof (long long);
+int pagesize = 0;
+long long cachesize = 128*1024*1024;
+int do_1514_point_query = 0;
+int dupflags = 0;
+int noserial = 0; // Don't do the serial stuff
+int norandom = 0; // Don't do the random stuff
+int prelock  = 0;
+int prelockflag = 0;
+int items_per_transaction = DEFAULT_ITEMS_PER_TRANSACTION;
+int items_per_iteration   = DEFAULT_ITEMS_TO_INSERT_PER_ITERATION;
+int finish_child_first = 0;  // Commit or abort child first (before doing so to the parent).  No effect if child does not exist.
+int singlex_child = 0;  // Do a single transaction, but do all work with a child
+int singlex = 0;  // Do a single transaction
+int singlex_create = 0;  // Create the db using the single transaction (only valid if singlex)
+int insert1first = 0;  // insert 1 before doing the rest
+int check_small_rolltmp = 0; // verify that the rollback logs are small (only valid if singlex)
+int do_transactions = 0;
+int if_transactions_do_logging = DB_INIT_LOG; // set this to zero if we want no logging when transactions are used
+int do_abort = 0;
+int n_insertions_since_txn_began=0;
+int env_open_flags = DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL;
+u_int32_t put_flags = DB_YESOVERWRITE;
+double compressibility = -1; // -1 means make it very compressible.  1 means use random bits everywhere.  2 means half the bits are random.
+int do_append = 0;
+int do_checkpoint_period = 0;
+u_int32_t checkpoint_period = 0;
+
+static void do_prelock(DB* db, DB_TXN* txn) {
+    if (prelock) {
+#if !defined(NO_DB_PRELOCKED)
+        int r = db->pre_acquire_table_lock(db, txn);
+        assert(r==0);
+#else
+	db = db; txn = txn;
+#endif
+    }
+}
+
+#define STRINGIFY2(s) #s
+#define STRINGIFY(s) STRINGIFY2(s)
+const char *dbdir = "./bench."  STRINGIFY(DIRSUF); /* DIRSUF is passed in as a -D argument to the compiler. */
+char *dbfilename = "bench.db";
+char *dbname;
+
+DB_ENV *dbenv;
+DB *db;
+DB_TXN *parenttid=0;
+DB_TXN *tid=0;
+
+
+static void benchmark_setup (void) {
+    int r;
+   
+    if (!do_append) {
+	char unlink_cmd[strlen(dbdir) + strlen("rm -rf ") + 1];
+	snprintf(unlink_cmd, sizeof(unlink_cmd), "rm -rf %s", dbdir);
+	//printf("unlink_cmd=%s\n", unlink_cmd);
+	system(unlink_cmd);
+
+        if (strcmp(dbdir, ".") != 0) {
+            r = toku_os_mkdir(dbdir,S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
+            assert(r == 0);
+        }
+    }
+
+    r = db_env_create(&dbenv, 0);
+    assert(r == 0);
+
+#if DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR <= 4
+    if (dbenv->set_lk_max) {
+	r = dbenv->set_lk_max(dbenv, items_per_transaction*2);
+	assert(r==0);
+    }
+#endif
+    if (dbenv->set_lk_max_locks) {
+        r = dbenv->set_lk_max_locks(dbenv, items_per_transaction*2);
+        assert(r == 0);
+    }
+
+    if (dbenv->set_cachesize) {
+        r = dbenv->set_cachesize(dbenv, cachesize / (1024*1024*1024), cachesize % (1024*1024*1024), 1);
+        if (r != 0) 
+            printf("WARNING: set_cachesize %d\n", r);
+    }
+    {
+	r = dbenv->open(dbenv, dbdir, env_open_flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+	assert(r == 0);
+    }
+
+#if defined(TOKUDB)
+    if (do_checkpoint_period) {
+        r = dbenv->checkpointing_set_period(dbenv, checkpoint_period);
+        assert(r == 0);
+        u_int32_t period;
+        r = dbenv->checkpointing_get_period(dbenv, &period);
+        assert(r == 0 && period == checkpoint_period);
+    }
+#endif
+
+    r = db_create(&db, dbenv, 0);
+    assert(r == 0);
+
+    if (do_transactions) {
+	r=dbenv->txn_begin(dbenv, 0, &tid, 0); CKERR(r);
+    }
+    if (pagesize && db->set_pagesize) {
+        r = db->set_pagesize(db, pagesize); 
+        assert(r == 0);
+    }
+    if (dupflags) {
+        r = db->set_flags(db, dupflags);
+        assert(r == 0);
+    }
+    r = db->open(db, tid, dbfilename, NULL, DB_BTREE, DB_CREATE, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+    if (r!=0) fprintf(stderr, "errno=%d, %s\n", errno, strerror(errno));
+    assert(r == 0);
+    if (insert1first) {
+        if (do_transactions) {
+            r=tid->commit(tid, 0);
+            assert(r==0);
+            tid = NULL;
+            r=dbenv->txn_begin(dbenv, 0, &tid, 0); CKERR(r);
+        }
+        insert(-1);
+        if (singlex) {
+            r=tid->commit(tid, 0);
+            assert(r==0);
+            tid = NULL;
+            r=dbenv->txn_begin(dbenv, 0, &tid, 0); CKERR(r);
+        }
+    }
+    else if (singlex && !singlex_create) {
+        r=tid->commit(tid, 0);
+        assert(r==0);
+        tid = NULL;
+        r=dbenv->txn_begin(dbenv, 0, &tid, 0); CKERR(r);
+    }
+    if (do_transactions) {
+	if (singlex)
+            do_prelock(db, tid);
+        else {
+            r=tid->commit(tid, 0);
+            assert(r==0);
+            tid = NULL;
+        }
+    }
+    if (singlex_child) {
+        parenttid = tid;
+        tid = NULL;
+        r=dbenv->txn_begin(dbenv, parenttid, &tid, 0); CKERR(r);
+    }
+
+}
+
+#if defined(TOKUDB)
+static void test1514(void);
+#endif
+static void benchmark_shutdown (void) {
+    int r;
+    
+#if defined(TOKUDB)
+    if (do_1514_point_query) test1514();
+#endif
+    if (do_transactions && singlex && !insert1first && (singlex_create || prelock)) {
+#if defined(TOKUDB)
+        //There should be a single 'truncate' in the rolltmp instead of many 'insert' entries.
+	struct txn_stat *s;
+	r = tid->txn_stat(tid, &s);
+	assert(r==0);
+        //TODO: #1125 Always do the test after performance testing is done.
+        if (singlex_child) fprintf(stderr, "SKIPPED 'small rolltmp' test for child txn\n");
+        else
+            assert(s->rolltmp_raw_count < 100);  // gross test, not worth investigating details
+	os_free(s);
+	//system("ls -l bench.tokudb");
+#endif
+    }
+    if (do_transactions && singlex) {
+        if (!singlex_child || finish_child_first) {
+            assert(tid);
+            r = (do_abort ? tid->abort(tid) : tid->commit(tid, 0));    assert(r==0);
+            tid = NULL; 
+        }
+        if (singlex_child) {
+            assert(parenttid);
+            r = (do_abort ? parenttid->abort(parenttid) : parenttid->commit(parenttid, 0));    assert(r==0);
+            parenttid = NULL;
+        }
+        else
+            assert(!parenttid);
+    }
+    assert(!tid);
+    assert(!parenttid);
+
+    r = db->close(db, 0);
+    assert(r == 0);
+    r = dbenv->close(dbenv, 0);
+    assert(r == 0);
+}
+
+static void long_long_to_array (unsigned char *a, int array_size, unsigned long long l) {
+    int i;
+    for (i=0; i<8 && i<array_size; i++)
+	a[i] = (l>>(56-8*i))&0xff;
+}
+
+static DBT *fill_dbt(DBT *dbt, const void *data, int size) {
+    memset(dbt, 0, sizeof *dbt);
+    dbt->size = size;
+    dbt->data = (void *) data;
+    return dbt;
+}
+
+// Fill array with 0's if compressibilty==-1, otherwise fill array with data that is likely to compress by a factor of compressibility.
+static void fill_array (unsigned char *data, int size) {
+    memset(data, 0, size);
+    if (compressibility>0) {
+	int i;
+	for (i=0; i<size/compressibility; i++) {
+	    data[i] = (unsigned char) random();
+	}
+    }
+}
+
+static void insert (long long v) {
+    unsigned char kc[keysize], vc[valsize];
+    DBT  kt, vt;
+    fill_array(kc, sizeof kc);
+    long_long_to_array(kc, keysize, v); // Fill in the array first, then write the long long in.
+    fill_array(vc, sizeof vc);
+    long_long_to_array(vc, valsize, v);
+    int r = db->put(db, tid, fill_dbt(&kt, kc, keysize), fill_dbt(&vt, vc, valsize), put_flags);
+    CKERR(r);
+    if (do_transactions) {
+	if (n_insertions_since_txn_began>=items_per_transaction && !singlex) {
+	    n_insertions_since_txn_began=0;
+	    r = tid->commit(tid, 0); assert(r==0);
+            tid = NULL;
+	    r=dbenv->txn_begin(dbenv, 0, &tid, 0); assert(r==0);
+            do_prelock(db, tid);
+	    n_insertions_since_txn_began=0;
+	}
+	n_insertions_since_txn_began++;
+    }
+}
+
+static void serial_insert_from (long long from) {
+    long long i;
+    if (do_transactions && !singlex) {
+	int r = dbenv->txn_begin(dbenv, 0, &tid, 0); assert(r==0);
+        do_prelock(db, tid);
+	{
+	    DBT k,v;
+	    r=db->put(db, tid, fill_dbt(&k, "a", 1), fill_dbt(&v, "b", 1), put_flags);
+	    CKERR(r);
+	}
+				      
+    }
+    for (i=0; i<items_per_iteration; i++) {
+	insert((from+i)*SERIAL_SPACING);
+    }
+    if (do_transactions && !singlex) {
+	int  r= tid->commit(tid, 0);             assert(r==0);
+	tid=NULL;
+    }
+}
+
+static long long llrandom (void) {
+    return (((long long)(random()))<<32) + random();
+}
+
+static void random_insert_below (long long below) {
+    long long i;
+    if (do_transactions && !singlex) {
+	int r = dbenv->txn_begin(dbenv, 0, &tid, 0); assert(r==0);
+        do_prelock(db, tid);
+    }
+    for (i=0; i<items_per_iteration; i++) {
+	insert(llrandom()%below);
+    }
+    if (do_transactions && !singlex) {
+	int  r= tid->commit(tid, 0);             assert(r==0);
+	tid=NULL;
+    }
+}
+
+static void biginsert (long long n_elements, struct timeval *starttime) {
+    long long i;
+    struct timeval t1,t2;
+    int iteration;
+    for (i=0, iteration=0; i<n_elements; i+=items_per_iteration, iteration++) {
+	if (!noserial) {
+	    gettimeofday(&t1,0);
+	    serial_insert_from(i);
+	    gettimeofday(&t2,0);
+	    if (verbose) printf("serial %9.6fs %8.0f/s    ", toku_tdiff(&t2, &t1), items_per_iteration/toku_tdiff(&t2, &t1));
+	    fflush(stdout);
+	}
+        if (!norandom) {
+	gettimeofday(&t1,0);
+	random_insert_below((i+items_per_iteration)*SERIAL_SPACING);
+	gettimeofday(&t2,0);
+	if (verbose) printf("random %9.6fs %8.0f/s    ", toku_tdiff(&t2, &t1), items_per_iteration/toku_tdiff(&t2, &t1));
+        }
+	if (verbose) printf("cumulative %9.6fs %8.0f/s\n", toku_tdiff(&t2, starttime), (((float)items_per_iteration*(!noserial+!norandom))/toku_tdiff(&t2, starttime))*(iteration+1));
+    }
+}
+
+
+
+const long long default_n_items = 1LL<<22;
+
+static int print_usage (const char *argv0) {
+    fprintf(stderr, "Usage:\n");
+    fprintf(stderr, " %s [-x] [--keysize KEYSIZE] [--valsize VALSIZE] [--noserial] [--norandom] [ n_iterations ]\n", argv0);
+    fprintf(stderr, "   where\n");
+    fprintf(stderr, "    -x              do transactions (XCOUNT transactions per iteration) (default: no transactions at all)\n");
+    fprintf(stderr, "    --keysize KEYSIZE sets the key size (default 8)\n");
+    fprintf(stderr, "    --valsize VALSIZE sets the value size (default 8)\n");
+    fprintf(stderr, "    --cachesize CACHESIZE set the database cache size\n");
+    fprintf(stderr, "    --pagesize PAGESIZE sets the database page size\n");
+    fprintf(stderr, "    --noserial         causes the serial insertions to be skipped\n");
+    fprintf(stderr, "    --norandom         causes the random insertions to be skipped\n");
+    fprintf(stderr, "    --compressibility C   creates data that should compress by about a factor C.   Default C is large.   C is an float.\n");
+    fprintf(stderr, "    --xcount N            how many insertions per transaction (default=%d)\n", DEFAULT_ITEMS_PER_TRANSACTION);
+    fprintf(stderr, "    --singlex             (implies -x) Run the whole job as a single transaction.  (Default don't run as a single transaction.)\n");
+    fprintf(stderr, "    --singlex-child       (implies -x) Run the whole job as a single transaction, do all work a child of that transaction.\n");
+    fprintf(stderr, "    --finish-child-first  Commit/abort child before doing so to parent (no effect if no child).\n");
+    fprintf(stderr, "    --singlex-create      (implies --singlex)  Create the file using the single transaction (Default is to use a different transaction to create.)\n");
+    fprintf(stderr, "    --check_small_rolltmp (Only valid in --singlex mode)  Verify that very little data was saved in the rollback logs.\n");
+    fprintf(stderr, "    --prelock             Prelock the database.\n");
+    fprintf(stderr, "    --prelockflag         Prelock the database and send the DB_PRELOCKED_WRITE flag.\n");
+    fprintf(stderr, "    --abort               Abort the singlex after the transaction is over. (Requires --singlex.)\n");
+    fprintf(stderr, "    --nolog               If transactions are used, then don't write the recovery log\n");
+    fprintf(stderr, "    --periter N           how many insertions per iteration (default=%d)\n", DEFAULT_ITEMS_TO_INSERT_PER_ITERATION);
+    fprintf(stderr, "    --DB_INIT_TXN (1|0)   turn on or off the DB_INIT_TXN env_open_flag\n");
+    fprintf(stderr, "    --DB_INIT_LOG (1|0)   turn on or off the DB_INIT_LOG env_open_flag\n");
+    fprintf(stderr, "    --DB_INIT_LOCK (1|0)  turn on or off the DB_INIT_LOCK env_open_flag\n");
+    fprintf(stderr, "    --1514                do a point query for something not there at end.  See #1514.  (Requires --norandom)\n");
+    fprintf(stderr, "    --env DIR\n");
+    fprintf(stderr, "    --append              append to an existing file\n");
+    fprintf(stderr, "    --checkpoint-period %"PRIu32"       checkpoint period\n", checkpoint_period); 
+    fprintf(stderr, "   n_iterations     how many iterations (default %lld)\n", default_n_items/DEFAULT_ITEMS_TO_INSERT_PER_ITERATION);
+
+    return 1;
+}
+
+#if defined(TOKUDB)
+static int
+nothing(DBT const* UU(key), DBT const* UU(val), void* UU(extra)) {
+    return 0;
+}
+
+static void
+test1514(void) {
+    assert(norandom); //Otherwise we can't know the given element is missing.
+    unsigned char kc[keysize], vc[valsize];
+    DBT  kt;
+    long long v = SERIAL_SPACING - 1;
+    fill_array(kc, sizeof kc);
+    long_long_to_array(kc, keysize, v); // Fill in the array first, then write the long long in.
+    fill_array(vc, sizeof vc);
+    long_long_to_array(vc, valsize, v);
+    int r;
+    DBC *c;
+
+
+    struct timeval t1,t2;
+
+    r = db->cursor(db, tid, &c, 0); CKERR(r);
+    gettimeofday(&t1,0);
+    r = c->c_getf_set(c, 0, fill_dbt(&kt, kc, keysize), nothing, NULL);
+    gettimeofday(&t2,0);
+    CKERR2(r, DB_NOTFOUND);
+    r = c->c_close(c); CKERR(r);
+
+    if (verbose) printf("(#1514) Single Point Query %9.6fs\n", toku_tdiff(&t2, &t1));
+}
+#endif
+
+int main (int argc, const char *argv[]) {
+    struct timeval t1,t2,t3;
+    long long total_n_items = default_n_items;
+    char *endptr;
+    int i;
+    for (i=1; i<argc; i++) {
+        const char *arg = argv[i];
+        if (arg[0] != '-')
+            break;
+	if (strcmp(arg, "-q") == 0) {
+	    verbose--; if (verbose<0) verbose=0;
+	} else if (strcmp(arg, "-x") == 0) {
+            do_transactions = 1;
+        } else if (strcmp(arg, "--noserial") == 0) {
+	    noserial=1;
+	} else if (strcmp(arg, "--norandom") == 0) {
+	    norandom=1;
+	} else if (strcmp(arg, "--compressibility") == 0) {
+	    compressibility = atof(argv[++i]);
+	} else if (strcmp(arg, "--nolog") == 0) {
+	    if_transactions_do_logging = 0;
+	} else if (strcmp(arg, "--singlex-create") == 0) {
+	    do_transactions = 1;
+	    singlex = 1;
+	    singlex_create = 1;
+	} else if (strcmp(arg, "--finish-child-first") == 0) {
+	    finish_child_first = 1;
+	} else if (strcmp(arg, "--singlex-child") == 0) {
+	    do_transactions = 1;
+	    singlex = 1;
+	    singlex_child = 1;
+	} else if (strcmp(arg, "--singlex") == 0) {
+	    do_transactions = 1;
+	    singlex = 1;
+	} else if (strcmp(arg, "--insert1first") == 0) {
+	    insert1first = 1;
+	} else if (strcmp(arg, "--check_small_rolltmp") == 0) {
+	    check_small_rolltmp = 1;
+	} else if (strcmp(arg, "--xcount") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            items_per_transaction = strtoll(argv[++i], &endptr, 10); assert(*endptr == 0);
+        } else if (strcmp(arg, "--abort") == 0) {
+            do_abort = 1;
+        } else if (strcmp(arg, "--periter") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            items_per_iteration = strtoll(argv[++i], &endptr, 10); assert(*endptr == 0);
+        } else if (strcmp(arg, "--cachesize") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            cachesize = strtoll(argv[++i], &endptr, 10); assert(*endptr == 0);
+        } else if (strcmp(arg, "--keysize") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            keysize = atoi(argv[++i]);
+        } else if (strcmp(arg, "--valsize") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            valsize = atoi(argv[++i]);
+        } else if (strcmp(arg, "--pagesize") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+           pagesize = atoi(argv[++i]);
+        } else if (strcmp(arg, "--dupsort") == 0) {
+            dupflags = DB_DUP + DB_DUPSORT;
+            continue;
+	} else if (strcmp(arg, "--env") == 0) {
+	    if (i+1 >= argc) return print_usage(argv[0]);
+	    dbdir = argv[++i];
+#if defined(TOKUDB)
+        } else if (strcmp(arg, "--1514") == 0) {
+            do_1514_point_query=1;
+#endif
+        } else if (strcmp(arg, "--prelock") == 0) {
+            prelock=1;
+        } else if (strcmp(arg, "--prelockflag") == 0) {
+            prelock=1;
+            prelockflag=1;
+        } else if (strcmp(arg, "--srandom") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            srandom(atoi(argv[++i]));
+        } else if (strcmp(arg, "--append") == 0) {
+            do_append = 1;
+        } else if (strcmp(arg, "--checkpoint-period") == 0) {
+            if (i+1 >= argc) return print_usage(argv[9]);
+            do_checkpoint_period = 1;
+            checkpoint_period = (u_int32_t) atoi(argv[++i]);
+        } else if (strcmp(arg, "--DB_INIT_TXN") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            if (atoi(argv[++i]))
+                env_open_flags |= DB_INIT_TXN;
+            else
+                env_open_flags &= ~DB_INIT_TXN;
+        } else if (strcmp(arg, "--DB_INIT_LOG") == 0) {
+            if (atoi(argv[++i]))
+                env_open_flags |= DB_INIT_LOG;
+            else
+                env_open_flags &= ~DB_INIT_LOG;
+        } else if (strcmp(arg, "--DB_INIT_LOCK") == 0) {
+            if (atoi(argv[++i]))
+                env_open_flags |= DB_INIT_LOCK;
+            else
+                env_open_flags &= ~DB_INIT_LOCK;
+        } else if (strcmp(arg, "--unique_checks") == 0) {
+            if (i+1 >= argc) return print_usage(argv[0]);
+            int unique_checks = atoi(argv[++i]);
+            if (unique_checks)
+                put_flags = DB_NOOVERWRITE;
+            else
+                put_flags = DB_YESOVERWRITE;
+        } else {
+	    return print_usage(argv[0]);
+	}
+    }
+    if (do_transactions) {
+	env_open_flags |= DB_INIT_TXN | if_transactions_do_logging | DB_INIT_LOCK;
+    }
+    if (do_transactions && prelockflag) {
+        put_flags |= DB_PRELOCKED_WRITE;
+    }
+    if (i<argc) {
+        /* if it looks like a number */
+        char *end;
+        errno=0;
+        long n_iterations = strtol(argv[i], &end, 10);
+        if (errno!=0 || *end!=0 || end==argv[i]) {
+            print_usage(argv[0]);
+            return 1;
+        }
+        total_n_items = items_per_iteration * (long long)n_iterations;
+    }
+    if (verbose) {
+	if (!noserial) printf("serial ");
+	if (!noserial && !norandom) printf("and ");
+	if (!norandom) printf("random ");
+	printf("insertions of %d per batch%s\n", items_per_iteration, do_transactions ? " (with transactions)" : "");
+    }
+#if !defined TOKUDB
+    if (check_small_rolltmp) {
+	fprintf(stderr, "--check_small_rolltmp only works on the TokuDB (not BDB)\n");
+	return print_usage(argv[0]);
+    }
+#endif
+    if (check_small_rolltmp && !singlex) {
+	fprintf(stderr, "--check_small_rolltmp requires --singlex\n");
+	return print_usage(argv[0]);
+    }
+    benchmark_setup();
+    gettimeofday(&t1,0);
+    biginsert(total_n_items, &t1);
+    gettimeofday(&t2,0);
+    benchmark_shutdown();
+    gettimeofday(&t3,0);
+    if (verbose) {
+	printf("Shutdown %9.6fs\n", toku_tdiff(&t3, &t2));
+	printf("Total time %9.6fs for %lld insertions = %8.0f/s\n", toku_tdiff(&t3, &t1), 
+	       (!noserial+!norandom)*total_n_items, (!noserial+!norandom)*total_n_items/toku_tdiff(&t3, &t1));
+    }
+#if 0 && defined TOKUDB
+    if (verbose) {
+	extern int toku_os_get_max_rss(int64_t*);
+        int64_t mrss;
+        int r = toku_os_get_max_rss(&mrss);
+        assert(r==0);
+	printf("maxrss=%.2fMB\n", mrss/256.0);
+    }
+    if (0) {
+	extern void print_hash_histogram (void) __attribute__((__visibility__("default")));
+	print_hash_histogram();
+    }
+#endif
+
+    return 0;
+}

release/examples/include/db.h

+#ifndef _DB_H
+#define _DB_H
+/* This code generated by make_db_h.   Copyright (c) 2007, 2008 Tokutek */
+#ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
+#include <sys/types.h>
+/*stdio is needed for the FILE* in db->verify*/
+#include <stdio.h>
+#if defined(__cplusplus)
+extern "C" {
+#endif
+#define TOKUDB 1
+#define TOKUDB_NATIVE_H 1
+#define DB_VERSION_MAJOR 4
+#define DB_VERSION_MINOR 6
+#define DB_VERSION_PATCH 19
+#ifndef _TOKUDB_WRAP_H
+#define DB_VERSION_STRING "Tokutek: TokuDB 4.6.19"
+#else
+#define DB_VERSION_STRING_ydb "Tokutek: TokuDB (wrapped bdb)"
+#endif
+#ifndef TOKU_OFF_T_DEFINED
+#define TOKU_OFF_T_DEFINED
+typedef int64_t toku_off_t;
+#endif
+typedef struct __toku_db_env DB_ENV;
+typedef struct __toku_db_key_range DB_KEY_RANGE;
+typedef struct __toku_db_lsn DB_LSN;
+typedef struct __toku_db DB;
+typedef struct __toku_db_txn DB_TXN;
+typedef struct __toku_db_txn_active DB_TXN_ACTIVE;
+typedef struct __toku_db_txn_stat DB_TXN_STAT;
+typedef struct __toku_dbc DBC;
+typedef struct __toku_dbt DBT;
+typedef u_int32_t db_recno_t;
+typedef int(*YDB_CALLBACK_FUNCTION)(DBT const*, DBT const*, void*);
+typedef int(*YDB_HEAVISIDE_CALLBACK_FUNCTION)(DBT const *key, DBT const *value, void *extra_f, int r_h);
+typedef int(*YDB_HEAVISIDE_FUNCTION)(const DBT *key, const DBT *value, void *extra_h);
+#include <tdb-internal.h>
+typedef struct __toku_db_btree_stat64 {
+  u_int64_t bt_nkeys; /* how many unique keys (guaranteed only to be an estimate, even when flattened)          */
+  u_int64_t bt_ndata; /* how many key-value pairs (an estimate, but exact when flattened)                       */
+  u_int64_t bt_dsize; /* how big are the keys+values (not counting the lengths) (an estimate, unless flattened) */
+  u_int64_t bt_fsize; /* how big is the underlying file                                                         */
+} DB_BTREE_STAT64;
+typedef enum {
+ DB_BTREE=1,
+ DB_UNKNOWN=5
+} DBTYPE;
+#ifndef _TOKUDB_WRAP_H
+#define DB_VERB_DEADLOCK 1
+#define DB_VERB_RECOVERY 8
+#define DB_VERB_REPLICATION 32
+#define DB_VERB_WAITSFOR 64
+#define DB_DBT_MALLOC 8
+#define DB_DBT_REALLOC 64
+#define DB_DBT_USERMEM 256
+#define DB_DBT_DUPOK 2
+#define DB_ARCH_ABS 1
+#define DB_ARCH_LOG 4
+#define DB_CREATE 1
+#define DB_CXX_NO_EXCEPTIONS 1
+#define DB_EXCL 16384
+#define DB_PRIVATE 8388608
+#define DB_RDONLY 32
+#define DB_RECOVER 64
+#define DB_THREAD 128
+#define DB_TXN_NOSYNC 512
+#define DB_LOCK_DEFAULT 1
+#define DB_LOCK_OLDEST 7
+#define DB_LOCK_RANDOM 8
+#define DB_DUP 32768
+#define DB_DUPSORT 65536
+#define DB_KEYFIRST 13
+#define DB_KEYLAST 14
+#define DB_NODUPDATA 19
+#define DB_NOOVERWRITE 20
+#define DB_YESOVERWRITE 254
+#define DB_OPFLAGS_MASK 255
+#define DB_AUTO_COMMIT 33554432
+#define DB_INIT_LOCK 131072
+#define DB_INIT_LOG 262144
+#define DB_INIT_MPOOL 524288
+#define DB_INIT_TXN 2097152
+#define DB_USE_ENVIRON 16384
+#define DB_USE_ENVIRON_ROOT 32768
+#define DB_READ_UNCOMMITTED 134217728
+#define DB_KEYEXIST -30996
+#define DB_LOCK_DEADLOCK -30995
+#define DB_LOCK_NOTGRANTED -30994
+#define DB_NOTFOUND -30989
+#define DB_SECONDARY_BAD -30974
+#define DB_DONOTINDEX -30998
+#define DB_BUFFER_SMALL -30999
+#define DB_BADFORMAT -30500
+#define DB_DELETE_ANY 65536
+#define DB_TRUNCATE_WITHCURSORS 131072
+#define DB_FIRST 7
+#define DB_GET_BOTH 8
+#define DB_GET_BOTH_RANGE 10
+#define DB_LAST 15
+#define DB_CURRENT 6
+#define DB_NEXT 16
+#define DB_NEXT_DUP 17
+#define DB_NEXT_NODUP 18
+#define DB_PREV 23
+#define DB_PREV_DUP 24
+#define DB_PREV_NODUP 25
+#define DB_SET 26
+#define DB_SET_RANGE 27
+#define DB_CURRENT_BINDING 253
+#define DB_RMW 1073741824
+#define DB_PRELOCKED 0x00800000
+#define DB_PRELOCKED_WRITE 0x00400000
+#define DB_DBT_APPMALLOC 1
+#define DB_DBT_MULTIPLE 16
+#define DB_LOG_AUTOREMOVE 524288
+#define DB_TXN_WRITE_NOSYNC 4096
+#define DB_TXN_NOWAIT 1024
+#define DB_TXN_SYNC 16384
+#endif
+/* TOKUDB specific error codes */
+#define TOKUDB_OUT_OF_LOCKS -100000
+#define TOKUDB_SUCCEEDED_EARLY -100001
+#define TOKUDB_DICTIONARY_TOO_OLD -100004
+#define TOKUDB_DICTIONARY_TOO_NEW -100005
+#define TOKUDB_DICTIONARY_NO_HEADER -100006
+#define TOKUDB_FOUND_BUT_REJECTED -100002
+#define TOKUDB_USER_CALLBACK_ERROR -100003
+/* in wrap mode, top-level function txn_begin is renamed, but the field isn't renamed, so we have to hack it here.*/
+#ifdef _TOKUDB_WRAP_H
+#undef txn_begin
+#endif
+struct __toku_db_env {
+  struct __toku_db_env_internal *i;
+#define db_env_struct_i(x) ((x)->i)
+  int (*checkpointing_set_period)             (DB_ENV*, u_int32_t) /* Change the delay between automatic checkpoints.  0 means disabled. */;
+  int (*checkpointing_get_period)             (DB_ENV*, u_int32_t*) /* Retrieve the delay between automatic checkpoints.  0 means disabled. */;
+  int (*checkpointing_postpone)               (DB_ENV*) /* Use for 'rename table' or any other operation that must be disjoint from a checkpoint */;
+  int (*checkpointing_resume)                 (DB_ENV*) /* Alert tokudb 'postpone' is no longer necessary */;
+  int (*checkpointing_begin_atomic_operation) (DB_ENV*) /* Begin a set of operations (that must be atomic as far as checkpoints are concerned). i.e. inserting into every index in one table */;
+  int (*checkpointing_end_atomic_operation)   (DB_ENV*) /* End   a set of operations (that must be atomic as far as checkpoints are concerned). */;
+  int (*set_default_bt_compare)  (DB_ENV*,int (*bt_compare) (DB *, const DBT *, const DBT *)) /* Set default (key) comparison function for all DBs in this environment.  Required for RECOVERY since you cannot open the DBs manually. */;
+  int (*set_default_dup_compare) (DB_ENV*,int (*bt_compare) (DB *, const DBT *, const DBT *)) /* Set default (val) comparison function for all DBs in this environment.  Required for RECOVERY since you cannot open the DBs manually. */;
+  void *app_private;
+  void *api1_internal;
+  int  (*close) (DB_ENV *, u_int32_t);
+  void (*err) (const DB_ENV *, int, const char *, ...);
+  int (*get_cachesize) (DB_ENV *, u_int32_t *, u_int32_t *, int *);
+  int (*get_flags) (DB_ENV *, u_int32_t *);
+  int  (*get_lg_max) (DB_ENV *, u_int32_t*);
+  int  (*get_lk_max_locks) (DB_ENV *, u_int32_t *);
+  int  (*log_archive) (DB_ENV *, char **[], u_int32_t);
+  int  (*log_flush) (DB_ENV *, const DB_LSN *);
+  int  (*open) (DB_ENV *, const char *, u_int32_t, int);
+  int  (*set_cachesize) (DB_ENV *, u_int32_t, u_int32_t, int);
+  int  (*set_data_dir) (DB_ENV *, const char *);
+  void (*set_errcall) (DB_ENV *, void (*)(const DB_ENV *, const char *, const char *));
+  void (*set_errfile) (DB_ENV *, FILE*);
+  void (*set_errpfx) (DB_ENV *, const char *);
+  int  (*set_flags) (DB_ENV *, u_int32_t, int);
+  int  (*set_lg_bsize) (DB_ENV *, u_int32_t);
+  int  (*set_lg_dir) (DB_ENV *, const char *);
+  int  (*set_lg_max) (DB_ENV *, u_int32_t);
+  int  (*set_lk_detect) (DB_ENV *, u_int32_t);
+  int  (*set_lk_max_locks) (DB_ENV *, u_int32_t);
+  int  (*set_tmp_dir) (DB_ENV *, const char *);
+  int  (*set_verbose) (DB_ENV *, u_int32_t, int);
+  int  (*txn_begin) (DB_ENV *, DB_TXN *, DB_TXN **, u_int32_t);
+  int  (*txn_checkpoint) (DB_ENV *, u_int32_t, u_int32_t, u_int32_t);
+  int  (*txn_stat) (DB_ENV *, DB_TXN_STAT **, u_int32_t);
+};
+struct __toku_db_key_range {
+  double less;
+  double equal;
+  double greater;
+};
+struct __toku_db_lsn {
+};
+struct __toku_dbt {
+  void*data;
+  u_int32_t size;
+  u_int32_t ulen;
+  u_int32_t flags;
+};
+typedef int (*toku_dbt_upgradef)(DB*,
+                                 u_int32_t old_version, const DBT *old_descriptor, const DBT *old_key, const DBT *old_val,
+                                 u_int32_t new_version, const DBT *new_descriptor, const DBT *new_key, const DBT *new_val);
+struct __toku_db {
+  struct __toku_db_internal *i;
+#define db_struct_i(x) ((x)->i)
+  int (*key_range64)(DB*, DB_TXN *, DBT *, u_int64_t *less, u_int64_t *equal, u_int64_t *greater, int *is_exact);
+  int (*stat64)(DB *, DB_TXN *, DB_BTREE_STAT64 *);
+  void *app_private;
+  DB_ENV *dbenv;
+  int (*pre_acquire_read_lock)(DB*, DB_TXN*, const DBT*, const DBT*, const DBT*, const DBT*);
+  int (*pre_acquire_table_lock)(DB*, DB_TXN*);
+  const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
+  const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
+  int (*delboth) (DB*, DB_TXN*, DBT*, DBT*, u_int32_t) /* Delete the key/value pair. */;
+  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  const DBT *descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
+  int (*set_descriptor) (DB*, u_int32_t version, const DBT* descriptor, toku_dbt_upgradef dbt_userformat_upgrade) /* set row/dictionary descriptor for a db.  Available only while db is open */;
+  void *api_internal;
+  int (*close) (DB*, u_int32_t);
+  int (*cursor) (DB *, DB_TXN *, DBC **, u_int32_t);
+  int (*del) (DB *, DB_TXN *, DBT *, u_int32_t);
+  int (*fd) (DB *, int *);
+  int (*get) (DB *, DB_TXN *, DBT *, DBT *, u_int32_t);
+  int (*get_flags) (DB *, u_int32_t *);
+  int (*get_pagesize) (DB *, u_int32_t *);
+  int (*key_range) (DB *, DB_TXN *, DBT *, DB_KEY_RANGE *, u_int32_t);
+  int (*open) (DB *, DB_TXN *, const char *, const char *, DBTYPE, u_int32_t, int);
+  int (*put) (DB *, DB_TXN *, DBT *, DBT *, u_int32_t);
+  int (*remove) (DB *, const char *, const char *, u_int32_t);
+  int (*rename) (DB *, const char *, const char *, const char *, u_int32_t);
+  int (*set_bt_compare) (DB *, int (*)(DB *, const DBT *, const DBT *));
+  int (*set_dup_compare) (DB *, int (*)(DB *, const DBT *, const DBT *));
+  void (*set_errfile) (DB *, FILE*);
+  int (*set_flags) (DB *, u_int32_t);
+  int (*set_pagesize) (DB *, u_int32_t);
+  int (*stat) (DB *, void *, u_int32_t);
+  int (*truncate) (DB *, DB_TXN *, u_int32_t *, u_int32_t);
+  int (*verify) (DB *, const char *, const char *, FILE *, u_int32_t);
+};
+struct __toku_db_txn_active {
+  u_int32_t txnid;
+  DB_LSN lsn;
+};
+struct txn_stat {
+  u_int64_t rolltmp_raw_count;
+};
+struct __toku_db_txn {
+  DB_ENV *mgrp /*In TokuDB, mgrp is a DB_ENV not a DB_TXNMGR*/;
+  DB_TXN *parent;
+  struct __toku_db_txn_internal ii;
+#define db_txn_struct_i(x) (&(x)->ii)
+  int (*txn_stat)(DB_TXN *, struct txn_stat **);
+  void *api_internal;
+  int (*abort) (DB_TXN *);
+  int (*commit) (DB_TXN*, u_int32_t);
+  u_int32_t (*id) (DB_TXN *);
+};
+struct __toku_db_txn_stat {
+  u_int32_t st_nactive;
+  DB_TXN_ACTIVE *st_txnarray;
+};
+struct __toku_dbc {
+  DB *dbp;
+  struct __toku_dbc_internal ii;
+#define dbc_struct_i(x) (&(x)->ii)
+  int (*c_getf_first)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_last)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_next)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_next_dup)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_next_nodup)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_prev)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_prev_dup)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_prev_nodup)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_current)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_current_binding)(DBC *, u_int32_t, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_heaviside)(DBC *, u_int32_t, YDB_HEAVISIDE_CALLBACK_FUNCTION f, void *extra_f, YDB_HEAVISIDE_FUNCTION h, void *extra_h, int direction);
+  int (*c_getf_set)(DBC *, u_int32_t, DBT *, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_set_range)(DBC *, u_int32_t, DBT *, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_get_both)(DBC *, u_int32_t, DBT *, DBT *, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_getf_get_both_range)(DBC *, u_int32_t, DBT *, DBT *, YDB_CALLBACK_FUNCTION, void *);
+  int (*c_close) (DBC *);
+  int (*c_count) (DBC *, db_recno_t *, u_int32_t);
+  int (*c_del) (DBC *, u_int32_t);
+  int (*c_get) (DBC *, DBT *, DBT *, u_int32_t);
+};
+#ifdef _TOKUDB_WRAP_H
+#define txn_begin txn_begin_tokudb
+#endif
+int db_env_create(DB_ENV **, u_int32_t) __attribute__((__visibility__("default")));
+int db_create(DB **, DB_ENV *, u_int32_t) __attribute__((__visibility__("default")));
+char *db_strerror(int) __attribute__((__visibility__("default")));
+const char *db_version(int*,int *,int *) __attribute__((__visibility__("default")));
+int log_compare (const DB_LSN*, const DB_LSN *) __attribute__((__visibility__("default")));
+int db_env_set_func_fsync (int (*)(int)) __attribute__((__visibility__("default")));
+int toku_set_trace_file (char *fname) __attribute__((__visibility__("default")));
+int toku_close_trace_file (void) __attribute__((__visibility__("default")));
+int db_env_set_func_free (void (*)(void*)) __attribute__((__visibility__("default")));
+int db_env_set_func_malloc (void *(*)(size_t)) __attribute__((__visibility__("default")));
+int db_env_set_func_pwrite (ssize_t (*)(int, const void *, size_t, toku_off_t)) __attribute__((__visibility__("default")));
+int db_env_set_func_write (ssize_t (*)(int, const void *, size_t)) __attribute__((__visibility__("default")));
+int db_env_set_func_realloc (void *(*)(void*, size_t)) __attribute__((__visibility__("default")));
+void db_env_set_checkpoint_callback (void (*)(void*), void*) __attribute__((__visibility__("default")));
+#if defined(__cplusplus)
+}
+#endif
+#endif