merge tokudb.1183 to main. addresses #1183

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

newbrt/brt-verify.c

@@ -171,7 +171,7 @@ int toku_verify_brtnode (BRT brt, BLOCKNUM blocknum, bytevec lorange, ITEMLEN lo
         struct check_increasing_arg ciarg = { brt , 0 };
 	toku_omt_iterate(node->u.l.buffer, check_increasing, &ciarg);
     }
-    if ((r = toku_cachetable_unpin(brt->cf, blocknum, fullhash, 0, 0))) return r;
+    if ((r = toku_cachetable_unpin(brt->cf, blocknum, fullhash, CACHETABLE_CLEAN, 0))) return r;
     return result;
 }
 

newbrt/brt.c

@@ -359,7 +359,7 @@ int toku_unpin_brtnode (BRT brt, BRTNODE node) {
 //    }
     verify_local_fingerprint_nonleaf(node);
     VERIFY_NODE(brt,node);
-    return toku_cachetable_unpin(brt->cf, node->thisnodename, node->fullhash, node->dirty, brtnode_memory_size(node));
+    return toku_cachetable_unpin(brt->cf, node->thisnodename, node->fullhash, (enum cachetable_dirty) node->dirty, brtnode_memory_size(node));
 }
 
 void toku_brtnode_flush_callback (CACHEFILE cachefile, BLOCKNUM nodename, void *brtnode_v, void *extraargs, long size __attribute__((unused)), BOOL write_me, BOOL keep_me, LSN modified_lsn __attribute__((__unused__)) , BOOL rename_p __attribute__((__unused__))) {
@@ -4281,7 +4281,7 @@ toku_dump_brtnode (FILE *file, BRT brt, BLOCKNUM blocknum, int depth, bytevec lo
 	//	     printf(" (%d)%u ", len, *(int*)le_any_key(data)));
 	fprintf(file, "\n");
     }
-    r = toku_cachetable_unpin(brt->cf, blocknum, fullhash, 0, 0);
+    r = toku_cachetable_unpin(brt->cf, blocknum, fullhash, CACHETABLE_CLEAN, 0);
     assert(r==0);
     return result;
 }

newbrt/cachetable.h

@@ -53,6 +53,7 @@ int toku_cachetable_openfd (CACHEFILE *,CACHETABLE, int /*fd*/, const char */*fn
 // Get access to the asynchronous work queue
 // Returns: a pointer to the work queue
 WORKQUEUE toku_cachetable_get_workqueue (CACHETABLE);
+
 void toku_cachefile_get_workqueue_load (CACHEFILE, int *n_in_queue, int *n_threads);
 
 // The flush callback is called when a key value pair is being written to storage and possibly removed from the cachetable.
@@ -73,7 +74,7 @@ void toku_cachefile_set_userdata(CACHEFILE cf, void *userdata, int (*close_userd
 // If userdata is already non-NULL, then we simply overwrite it.
 
 void *toku_cachefile_get_userdata(CACHEFILE);
-// Effect: Get the user dataa.
+// Effect: Get the user data.
 
 // Put a memory object into the cachetable.
 // Effects: Lookup the key in the cachetable. If the key is not in the cachetable, 
@@ -103,8 +104,8 @@ int toku_cachetable_get_and_pin(CACHEFILE, CACHEKEY, u_int32_t /*fullhash*/,
 // void**.  If the item is not in memory, then return a nonzero error number.
 int toku_cachetable_maybe_get_and_pin (CACHEFILE, CACHEKEY, u_int32_t /*fullhash*/, void**);
 
-// cachetable object state WRT external memory
-enum cachetable_object_state {
+// cachetable pair clean or dirty WRT external memory
+enum cachetable_dirty {
     CACHETABLE_CLEAN=0, // the cached object is clean WRT the cachefile
     CACHETABLE_DIRTY=1, // the cached object is dirty WRT the cachefile
 };
@@ -113,7 +114,7 @@ enum cachetable_object_state {
 // Effects: If the memory object is in the cachetable, then OR the dirty flag, 
 // update the size, and release the read lock on the memory object.
 // Returns: 0 if success, otherwise returns an error number.
-int toku_cachetable_unpin(CACHEFILE, CACHEKEY, u_int32_t fullhash, int dirty, long size);
+int toku_cachetable_unpin(CACHEFILE, CACHEKEY, u_int32_t fullhash, enum cachetable_dirty dirty, long size);
 
 int toku_cachetable_unpin_and_remove (CACHEFILE, CACHEKEY); /* Removing something already present is OK. */
 // Effect: Remove an object from the cachetable.  Don't write it back.

newbrt/recover.c

@@ -213,7 +213,7 @@ toku_recover_newbrtnode (LSN lsn, FILENUM filenum, BLOCKNUM blocknum,u_int32_t h
     VERIFY_COUNTS(n);
 
     n->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, blocknum, fullhash, 1, toku_serialize_brtnode_size(n));
+    r = toku_cachetable_unpin(pair->cf, blocknum, fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(n));
     assert(r==0);
 }
 
@@ -249,7 +249,7 @@ static void toku_recover_deqrootentry (LSN lsn __attribute__((__unused__)), FILE
     assert(r==0);
     r = toku_fifo_deq(h->fifo);
     assert(r==0);
-    //r = toku_cachetable_unpin(pair->cf, header_blocknum, fullhash, 1, 0);
+    //r = toku_cachetable_unpin(pair->cf, header_blocknum, fullhash, CACHETABLE_DIRTY, 0);
     //assert(r==0);
 }
 
@@ -270,7 +270,7 @@ toku_recover_enqrootentry (LSN lsn __attribute__((__unused__)), FILENUM filenum,
     struct brt_header *h=h_v;
     r = toku_fifo_enq(h->fifo, key.data, key.len, val.data, val.len, typ, xid); 
     assert(r==0);
-    r = toku_cachetable_unpin(pair->cf, header_blocknum, fullhash, 1, 0);
+    r = toku_cachetable_unpin(pair->cf, header_blocknum, fullhash, CACHETABLE_DIRTY, 0);
     assert(r==0);
     toku_free(key.data);
     toku_free(val.data);
@@ -297,7 +297,7 @@ toku_recover_brtdeq (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t chil
     node->u.n.n_bytes_in_buffers -= sizediff;
     BNC_NBYTESINBUF(node, childnum) -= sizediff;
     r = toku_fifo_deq(BNC_BUFFER(node, childnum)); // don't deq till were' done looking at the data.
-    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 }
 
@@ -314,7 +314,7 @@ toku_recover_brtenq (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t chil
     node->local_fingerprint += node->rand4fingerprint * toku_calc_fingerprint_cmd(typ, xid, key.data, key.len, data.data, data.len);
     node->log_lsn = lsn;
     u_int32_t sizediff = key.len + data.len + KEY_VALUE_OVERHEAD + BRT_CMD_OVERHEAD;
-    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
     node->u.n.n_bytes_in_buffers += sizediff;
     BNC_NBYTESINBUF(node, childnum) += sizediff;
@@ -348,7 +348,7 @@ toku_recover_addchild (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t ch
     BNC_NBYTESINBUF(node, childnum) = 0;
     node->u.n.n_children++;
     node->log_lsn = lsn;
-    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 }
 
@@ -385,7 +385,7 @@ toku_recover_delchild (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t ch
     node->u.n.n_children--;
 
     node->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
     toku_free(pivotkey.data);
 }
@@ -406,7 +406,7 @@ toku_recover_setchild (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t ch
     assert(childnum < (unsigned)node->u.n.n_children);
     BNC_BLOCKNUM(node, childnum) = newchild;
     node->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 }
 static void
@@ -429,7 +429,7 @@ toku_recover_setpivot (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int32_t ch
     node->u.n.totalchildkeylens += toku_brt_pivot_key_len(pair->brt, node->u.n.childkeys[childnum]);
 
     node->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 
     toku_free(pivotkey.data);
@@ -452,7 +452,7 @@ toku_recover_changechildfingerprint (LSN lsn, FILENUM filenum, BLOCKNUM blocknum
     assert((signed)childnum <= node->u.n.n_children); // we allow the childnum to be one too large.
     BNC_SUBTREE_FINGERPRINT(node, childnum) = newfingerprint;
     node->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 }
 #endif
@@ -598,10 +598,10 @@ toku_recover_leafsplit (LSN lsn, FILENUM filenum, BLOCKNUM old_blocknum, BLOCKNU
     toku_cachetable_put(pair->cf, new_blocknum, newn->fullhash,
 			newn, toku_serialize_brtnode_size(newn), toku_brtnode_flush_callback, toku_brtnode_fetch_callback, 0);
     newn->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, new_blocknum, newn->fullhash, 1, toku_serialize_brtnode_size(newn));
+    r = toku_cachetable_unpin(pair->cf, new_blocknum, newn->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(newn));
     assert(r==0);
     oldn->log_lsn = lsn;
-    r = toku_cachetable_unpin(pair->cf, old_blocknum, oldn->fullhash, 1, toku_serialize_brtnode_size(oldn));
+    r = toku_cachetable_unpin(pair->cf, old_blocknum, oldn->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(oldn));
     assert(r==0);
 }
 
@@ -630,7 +630,7 @@ toku_recover_insertleafentry (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int
 	node->u.l.n_bytes_in_buffer += OMT_ITEM_OVERHEAD + leafentry_disksize(newleafentry);
 	node->local_fingerprint += node->rand4fingerprint * toku_le_crc(newleafentry);
     }
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
     toku_free_LEAFENTRY(newleafentry);
 }
@@ -663,7 +663,7 @@ toku_recover_deleteleafentry (LSN lsn, FILENUM filenum, BLOCKNUM blocknum, u_int
 	r = toku_omt_delete_at(node->u.l.buffer, idx);
 	assert(r==0);
     }
-    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, 1, toku_serialize_brtnode_size(node));
+    r = toku_cachetable_unpin(pair->cf, blocknum, node->fullhash, CACHETABLE_DIRTY, toku_serialize_brtnode_size(node));
     assert(r==0);
 }
 

newbrt/tests/Makefile

@@ -45,6 +45,15 @@ REGRESSION_TESTS_RAW = \
 	cachetable-count-pinned-test \
 	cachetable-debug-test \
 	cachetable-debug-test \
+	cachetable-checkpoint-test \
+	cachetable-prefetch-maybegetandpin-test \
+	cachetable-prefetch2-test \
+	cachetable-prefetch-close-test \
+	cachetable-prefetch-close-fail-test \
+	cachetable-prefetch-getandpin-test \
+	cachetable-prefetch-getandpin-fail-test \
+	cachetable-prefetch-checkpoint-test \
+	cachetable-prefetch-flowcontrol-test \
 	fifo-test \
 	list-test \
 	keyrange \

newbrt/tests/cachetable-checkpoint-test.c

@@ -5,28 +5,33 @@
 #include "test.h"
 #include "cachetable.h"
 
-const int item_size = 1;
+static const int item_size = 1;
 
-int n_flush, n_write_me, n_keep_me, n_fetch;
+static int n_flush, n_write_me, n_keep_me, n_fetch;
 
-void flush(CACHEFILE cf, CACHEKEY key, void *value, long size, BOOL write_me, BOOL keep_me, LSN modified_lsn, BOOL rename_p) {
-    cf = cf; modified_lsn = modified_lsn; rename_p = rename_p;
-    assert(key == (CACHEKEY)(long)value);
+static void flush(CACHEFILE cf, CACHEKEY key, void *value, void *extraargs, long size, BOOL write_me, BOOL keep_me, LSN modified_lsn, BOOL rename_p) {
+    cf = cf; key = key; value = value; extraargs = extraargs; modified_lsn = modified_lsn; rename_p = rename_p;
+    // assert(key == make_blocknum((long)value));
     assert(size == item_size);
     n_flush++;
     if (write_me) n_write_me++;
     if (keep_me) n_keep_me++;
 }
 
-int fetch() {
+static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs, LSN *written_lsn) {
+    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs; written_lsn = written_lsn;
+    assert(0); // should not be called
     n_fetch++;
+    *value = 0;
+    *sizep = item_size;
     return 0;
 }
 
 // put n items into the cachetable, maybe mark them dirty, do a checkpoint, and
 // verify that all of the items have been written and are clean.
 
-void cachetable_checkpoint_test(int n, int dirty) {
+static void cachetable_checkpoint_test(int n, enum cachetable_dirty dirty) {
+    if (verbose) printf("%s:%d n=%d dirty=%d\n", __FUNCTION__, __LINE__, n, (int) dirty);
     const int test_limit = n;
     int r;
     CACHETABLE ct;
@@ -39,18 +44,19 @@ void cachetable_checkpoint_test(int n, int dirty) {
     // insert items into the cachetable. all should be dirty
     int i;
     for (i=0; i<n; i++) {
-        u_int32_t hi = toku_cachetable_hash(f1, i);
-        r = toku_cachetable_put(f1, i, hi, (void *)(long)i, 1, flush, fetch, 0);
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t hi = toku_cachetable_hash(f1, key);
+        r = toku_cachetable_put(f1, key, hi, (void *)(long)i, 1, flush, fetch, 0);
         assert(r == 0);
 
-        r = toku_cachetable_unpin(f1, i, hi, dirty, item_size);
+        r = toku_cachetable_unpin(f1, key, hi, dirty, item_size);
         assert(r == 0);
 
         void *v;
         int its_dirty;
         long long its_pin;
         long its_size;
-        r = toku_cachetable_get_key_state(ct, i, f1, &v, &its_dirty, &its_pin, &its_size);
+        r = toku_cachetable_get_key_state(ct, key, f1, &v, &its_dirty, &its_pin, &its_size);
         if (r != 0) 
             continue;
         assert(its_dirty == CACHETABLE_DIRTY);
@@ -67,18 +73,19 @@ void cachetable_checkpoint_test(int n, int dirty) {
 
     // after the checkpoint, all of the items should be clean
     for (i=0; i<n; i++) {
-        u_int32_t hi = toku_cachetable_hash(f1, i);
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t hi = toku_cachetable_hash(f1, key);
         void *v;
-        r = toku_cachetable_maybe_get_and_pin(f1, i, hi, &v);
+        r = toku_cachetable_maybe_get_and_pin(f1, key, hi, &v);
         if (r != 0) 
             continue;
-        r = toku_cachetable_unpin(f1, i, hi, CACHETABLE_CLEAN, item_size);
+        r = toku_cachetable_unpin(f1, key, hi, CACHETABLE_CLEAN, item_size);
         assert(r == 0);
         
         int its_dirty;
         long long its_pin;
         long its_size;
-        r = toku_cachetable_get_key_state(ct, i, f1, &v, &its_dirty, &its_pin, &its_size);
+        r = toku_cachetable_get_key_state(ct, key, f1, &v, &its_dirty, &its_pin, &its_size);
         if (r != 0) 
             continue;
         assert(its_dirty == CACHETABLE_CLEAN);
@@ -93,7 +100,7 @@ void cachetable_checkpoint_test(int n, int dirty) {
     assert(r == 0);
     assert(n_flush == n && n_write_me == 0 && n_keep_me == n);
 
-    r = toku_cachefile_close(&f1, NULL_LOGGER); assert(r == 0 && f1 == 0);
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
     r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
 }
 

newbrt/tests/cachetable-prefetch-checkpoint-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+// verify that the cache table checkpoint with prefetched blocks active works.
+// the blocks in the reading state should be ignored.
+#include <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "test.h"
+#include "cachetable.h"
+
+const int item_size = 1;
+
+int n_flush, n_write_me, n_keep_me, n_fetch;
+
+static void flush(CACHEFILE cf, CACHEKEY key, void *value, void *extraargs, long size, BOOL write_me, BOOL keep_me, LSN modified_lsn, BOOL rename_p) {
+    cf = cf; key = key; value = value; extraargs = extraargs; modified_lsn = modified_lsn; rename_p = rename_p;
+    // assert(key == make_blocknum((long)value));
+    assert(size == item_size);
+    n_flush++;
+    if (write_me) n_write_me++;
+    if (keep_me) n_keep_me++;
+}
+
+static int fetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, void *extraargs, LSN *written_lsn) {
+    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs; written_lsn = written_lsn;
+    n_fetch++;
+    sleep(10);
+    *value = 0;
+    *sizep = item_size;
+    return 0;
+}
+
+// put n items into the cachetable, maybe mark them dirty, do a checkpoint, and
+// verify that all of the items have been written and are clean.
+static void cachetable_prefetch_checkpoint_test(int n, enum cachetable_dirty dirty) {
+    if (verbose) printf("%s:%d n=%d dirty=%d\n", __FUNCTION__, __LINE__, n, (int) dirty);
+    const int test_limit = n;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    // prefetch block n+1. this will take 10 seconds.
+    {
+        CACHEKEY key = make_blocknum(n+1);
+        u_int32_t fullhash = toku_cachetable_hash(f1, key);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+        toku_cachetable_verify(ct);
+    }
+
+    // insert items into the cachetable. all should be dirty
+    int i;
+    for (i=0; i<n; i++) {
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t hi = toku_cachetable_hash(f1, key);
+        r = toku_cachetable_put(f1, key, hi, (void *)(long)i, 1, flush, fetch, 0);
+        assert(r == 0);
+
+        r = toku_cachetable_unpin(f1, key, hi, dirty, item_size);
+        assert(r == 0);
+
+        void *v;
+        int its_dirty;
+        long long its_pin;
+        long its_size;
+        r = toku_cachetable_get_key_state(ct, key, f1, &v, &its_dirty, &its_pin, &its_size);
+        if (r != 0) 
+            continue;
+        assert(its_dirty == CACHETABLE_DIRTY);
+        assert(its_pin == 0);
+        assert(its_size == item_size);
+    }
+
+    // the checkpoint should cause n writes, but since n <= the cachetable size,
+    // all items should be kept in the cachetable
+    n_flush = n_write_me = n_keep_me = n_fetch = 0;
+    r = toku_cachetable_checkpoint(ct);
+    assert(r == 0);
+    assert(n_flush == n && n_write_me == n && n_keep_me == n);
+
+    // after the checkpoint, all of the items should be clean
+    for (i=0; i<n; i++) {
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t hi = toku_cachetable_hash(f1, key);
+        void *v;
+        r = toku_cachetable_maybe_get_and_pin(f1, key, hi, &v);
+        if (r != 0) 
+            continue;
+        r = toku_cachetable_unpin(f1, key, hi, CACHETABLE_CLEAN, item_size);
+        assert(r == 0);
+        
+        int its_dirty;
+        long long its_pin;
+        long its_size;
+        r = toku_cachetable_get_key_state(ct, key, f1, &v, &its_dirty, &its_pin, &its_size);
+        if (r != 0) 
+            continue;
+        assert(its_dirty == CACHETABLE_CLEAN);
+        assert(its_pin == 0);
+        assert(its_size == item_size);
+    }
+
+    // a subsequent checkpoint should cause n flushes, but no writes since all
+    // of the items are clean
+    n_flush = n_write_me = n_keep_me = n_fetch = 0;
+    r = toku_cachetable_checkpoint(ct);
+    assert(r == 0);
+    assert(n_flush == n && n_write_me == 0 && n_keep_me == n);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    int i;
+    for (i=1; i<argc; i++) {
+        if (strcmp(argv[i], "-v") == 0) {
+            verbose++;
+            continue;
+        }
+    }
+    for (i=0; i<8; i++) {
+        cachetable_prefetch_checkpoint_test(i, CACHETABLE_CLEAN);
+        cachetable_prefetch_checkpoint_test(i, CACHETABLE_DIRTY);
+    }
+    return 0;
+}

newbrt/tests/cachetable-prefetch-close-fail-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+// verify that closing the cachetable with prefetches in progress works
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int fetch_calls = 0;
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    fetch_calls++;
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return -42;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // close with the prefetch in progress. the close should block until
+    // all of the reads and writes are complete.
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-prefetch-close-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+// verify that closing the cachetable with prefetches in progress works
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int fetch_calls = 0;
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    fetch_calls++;
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return 0;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // close with the prefetch in progress. the close should block until
+    // all of the reads and writes are complete.
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-prefetch-flowcontrol-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+// verify that cachetable prefetch multiple blocks hits the cachetable size limit
+// and flushes eventually happen.
+
+#include "includes.h"
+#include "test.h"
+
+static int flush_calls = 0;
+static int flush_evict_calls = 0;
+static int evicted_keys = 0;
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+    flush_calls++;
+    if (keep == FALSE) {
+        flush_evict_calls++;
+	if (verbose) printf("%s:%d flush %"PRId64"\n", __FUNCTION__, __LINE__, k.b);
+        evicted_keys |= 1 << k.b;
+    }
+}
+
+static int fetch_calls = 0;
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    fetch_calls++;
+    if (verbose) printf("%s:%d %"PRId64"\n", __FUNCTION__, __LINE__, k.b);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return 0;
+}
+
+// Note: cachetable_size_limit must be a power of 2
+static void cachetable_prefetch_flowcontrol_test (int cachetable_size_limit) {
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, cachetable_size_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    int i;
+
+    // prefetch keys 0 .. N-1.  they should all fit in the cachetable
+    for (i=0; i<cachetable_size_limit; i++) {
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t fullhash = toku_cachetable_hash(f1, key);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+        toku_cachetable_verify(ct);
+    }
+
+    // wait for all of the blocks to be fetched
+    sleep(10);
+
+    // prefetch keys N .. 2*N-1.  0 .. N-1 should be evicted.
+    for (i=i; i<2*cachetable_size_limit; i++) {
+        CACHEKEY key = make_blocknum(i);
+        u_int32_t fullhash = toku_cachetable_hash(f1, key);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+        toku_cachetable_verify(ct);
+	// sleep(1);
+    }
+
+    // wait for everything to finish
+    sleep(10);
+    assert(flush_evict_calls == cachetable_size_limit);
+    assert(evicted_keys == (1 << cachetable_size_limit)-1);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    if (verbose) printf("%s:%d 0x%x 0x%x\n", __FUNCTION__, __LINE__,
+	evicted_keys, (1 << (2*cachetable_size_limit))-1);
+    assert(evicted_keys == (1 << (2*cachetable_size_limit))-1);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_flowcontrol_test(8);
+    return 0;
+}

newbrt/tests/cachetable-prefetch-getandpin-fail-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+/* verify that get_and_pin waits while a prefetch block is pending */
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return -42;
+}
+
+static uint64_t tdelta_usec(struct timeval *tend, struct timeval *tstart) {
+    uint64_t t = tend->tv_sec * 1000000 + tend->tv_usec;
+    t -= tstart->tv_sec * 1000000 + tstart->tv_usec;
+    return t;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    struct timeval tstart;
+    gettimeofday(&tstart, NULL);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // verify that get_and_pin waits while the prefetch is in progress
+    void *v = 0;
+    long size = 0;
+    r = toku_cachetable_get_and_pin(f1, key, fullhash, &v, &size, flush, fetch, NULL);
+    assert(r != 0);
+
+    struct timeval tend; 
+    gettimeofday(&tend, NULL);
+
+    assert(tdelta_usec(&tend, &tstart) >= 10000000); 
+    
+    toku_cachetable_verify(ct);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-prefetch-getandpin-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+/* verify that get_and_pin waits while a prefetch block is pending */
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return 0;
+}
+
+static uint64_t tdelta_usec(struct timeval *tend, struct timeval *tstart) {
+    uint64_t t = tend->tv_sec * 1000000 + tend->tv_usec;
+    t -= tstart->tv_sec * 1000000 + tstart->tv_usec;
+    return t;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    struct timeval tstart;
+    gettimeofday(&tstart, NULL);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // verify that get_and_pin waits while the prefetch is in progress
+    void *v = 0;
+    long size = 0;
+    r = toku_cachetable_get_and_pin(f1, key, fullhash, &v, &size, flush, fetch, NULL);
+    assert(r == 0 && v == 0 && size == 1);
+
+    struct timeval tend; 
+    gettimeofday(&tend, NULL);
+
+    assert(tdelta_usec(&tend, &tstart) >= 10000000); 
+    
+    toku_cachetable_verify(ct);
+
+    r = toku_cachetable_unpin(f1, key, fullhash, CACHETABLE_CLEAN, 1);
+    assert(r == 0);
+    toku_cachetable_verify(ct);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-prefetch-maybegetandpin-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+/* verify that maybe_get_and_pin returns an error while a prefetch block is pending */
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return 0;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // verify that maybe_get_and_pin returns an error while the prefetch is in progress
+    int i;
+    for (i=1; i>=0; i++) {
+        void *v;
+        r = toku_cachetable_maybe_get_and_pin(f1, key, fullhash, &v);
+        if (r == 0) break;
+        toku_pthread_yield();
+    }
+    if (verbose) printf("%s:%d %d\n", __FUNCTION__, __LINE__, i);
+    assert(i>1);
+    toku_cachetable_verify(ct);
+
+    r = toku_cachetable_unpin(f1, key, fullhash, CACHETABLE_CLEAN, 1);
+    assert(r == 0);
+    toku_cachetable_verify(ct);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-prefetch2-test.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+
+// verify that cachetable prefetch of the same block multiple times only
+// fetches the block once.
+#include "includes.h"
+#include "test.h"
+
+static void
+flush (CACHEFILE f __attribute__((__unused__)),
+       CACHEKEY k  __attribute__((__unused__)),
+       void *v     __attribute__((__unused__)),
+       void *e     __attribute__((__unused__)),
+       long s      __attribute__((__unused__)),
+       BOOL w      __attribute__((__unused__)),
+       BOOL keep   __attribute__((__unused__)),
+       LSN m       __attribute__((__unused__)),
+       BOOL r      __attribute__((__unused__))
+       ) {
+    assert(w == FALSE);
+}
+
+static int fetch_calls = 0;
+
+static int
+fetch (CACHEFILE f        __attribute__((__unused__)),
+       CACHEKEY k         __attribute__((__unused__)),
+       u_int32_t fullhash __attribute__((__unused__)),
+       void **value       __attribute__((__unused__)),
+       long *sizep        __attribute__((__unused__)),
+       void *extraargs    __attribute__((__unused__)),
+       LSN *written_lsn    __attribute__((__unused__))
+       ) {
+
+    fetch_calls++;
+    sleep(10);
+
+    *value = 0;
+    *sizep = 1;
+    *written_lsn = ZERO_LSN;
+
+    return 0;
+}
+
+static void cachetable_prefetch_maybegetandpin_test (void) {
+    const int test_limit = 1;
+    int r;
+    CACHETABLE ct;
+    r = toku_create_cachetable(&ct, test_limit, ZERO_LSN, NULL_LOGGER); assert(r == 0);
+    char fname1[] = __FILE__ "test1.dat";
+    unlink(fname1);
+    CACHEFILE f1;
+    r = toku_cachetable_openf(&f1, ct, fname1, O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO); assert(r == 0);
+
+    // prefetch block 0. this will take 10 seconds.
+    CACHEKEY key = make_blocknum(0);
+    u_int32_t fullhash = toku_cachetable_hash(f1, make_blocknum(0));
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // prefetch again. this should do nothing.
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, 0);
+    toku_cachetable_verify(ct);
+
+    // verify that maybe_get_and_pin returns an error while the prefetch is in progress
+    int i;
+    for (i=1; i>=0; i++) {
+        void *v;
+        r = toku_cachetable_maybe_get_and_pin(f1, key, fullhash, &v);
+        if (r == 0) break;
+        toku_pthread_yield();
+    }
+    if (verbose) printf("%s:%d %d\n", __FUNCTION__, __LINE__, i);
+    assert(i>1);
+    toku_cachetable_verify(ct);
+
+    // there should only be 1 fetch callback
+    assert(fetch_calls == 1);
+
+    r = toku_cachetable_unpin(f1, key, fullhash, CACHETABLE_CLEAN, 1);
+    assert(r == 0);
+    toku_cachetable_verify(ct);
+
+    r = toku_cachefile_close(&f1, NULL_LOGGER, 0); assert(r == 0 && f1 == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0 && ct == 0);
+}
+
+int
+test_main(int argc, const char *argv[]) {
+    default_parse_args(argc, argv);
+    cachetable_prefetch_maybegetandpin_test();
+    return 0;
+}

newbrt/tests/cachetable-scan.c

@@ -67,7 +67,7 @@ static void writeit (void) {
 	int j;
 	for (j=0; j<BLOCKSIZE; j++) ((char*)buf)[j]=(char)((i+j)%256);
 	r = toku_cachetable_put(f, key, fullhash, buf, BLOCKSIZE, f_flush, f_fetch, 0);	assert(r==0);
-	r = toku_cachetable_unpin(f, key, fullhash, 0, BLOCKSIZE);                      assert(r==0);
+	r = toku_cachetable_unpin(f, key, fullhash, CACHETABLE_CLEAN, BLOCKSIZE); assert(r==0);
     }
     gettimeofday(&end, 0);
     double diff = tdiff(&end, &start);
@@ -87,7 +87,7 @@ static void readit (void) {
 	CACHEKEY key = make_blocknum(i*BLOCKSIZE);
 	u_int32_t fullhash = toku_cachetable_hash(f, key);
 	r=toku_cachetable_get_and_pin(f, key, fullhash, &block, &current_size, f_flush, f_fetch, 0); assert(r==0);
-	r=toku_cachetable_unpin(f, key, fullhash, 0, BLOCKSIZE);                                      assert(r==0);
+	r=toku_cachetable_unpin(f, key, fullhash, CACHETABLE_CLEAN, BLOCKSIZE);                                      assert(r==0);
     }
     r = toku_cachefile_close(&f, 0, 0);    assert(r == 0);
     r = toku_cachetable_close(&t);      assert(r == 0);

newbrt/tests/cachetable-test.c

@@ -29,7 +29,7 @@ static inline void test_mutex_unlock() {
 // hook my_malloc_always_fails into malloc to control malloc and verify
 // the correct recovery from malloc failures
 #if defined(__linux__)
-#define DO_MALLOC_HOOK 0
+#define DO_MALLOC_HOOK 1
 #else
 #define DO_MALLOC_HOOK 0
 #endif
@@ -334,19 +334,19 @@ static void test_nested_pin (void) {
     assert(r==0);
     assert(vv==&i0);
     assert(i0==0);
-    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, 0, test_object_size);
+    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, CACHETABLE_CLEAN, test_object_size);
     assert(r==0);
     r = toku_cachetable_maybe_get_and_pin(f, make_blocknum(1), f1hash, &vv2);
     assert(r==0);
     assert(vv2==vv);
-    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, 0, test_object_size);
+    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, CACHETABLE_CLEAN, test_object_size);
     assert(r==0);
     u_int32_t f2hash = toku_cachetable_hash(f, make_blocknum(2));
     r = toku_cachetable_put(f, make_blocknum(2), f2hash, &i1, test_object_size, flush_n, fetch_n, f2);
     assert(r==0); // The other one is pinned, but now the cachetable fails gracefully:  It allows the pin to happen
-    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, 0, test_object_size);
+    r = toku_cachetable_unpin(f, make_blocknum(1), f1hash, CACHETABLE_CLEAN, test_object_size);
     assert(r==0);
-    r = toku_cachetable_unpin(f, make_blocknum(2), f2hash, 0, test_object_size);
+    r = toku_cachetable_unpin(f, make_blocknum(2), f2hash, CACHETABLE_CLEAN, test_object_size);
     assert(r==0);
     //    toku_os_usleep(1*1000000);
     r = toku_cachefile_close(&f, 0, 0); assert(r==0);

newbrt/tests/threadpool-test.c

@@ -63,7 +63,7 @@ my_thread_f (void *arg) {
 }
 
 #if defined(__linux__)
-#define DO_MALLOC_HOOK 0
+#define DO_MALLOC_HOOK 1
 #else
 #define DO_MALLOC_HOOK 0
 #endif