[t:3644], merge cachetable changes for #3627 from tokudb.3627 to main

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

newbrt/brt-internal.h

@@ -312,6 +312,8 @@ struct brtenv {
 extern void toku_brtnode_flush_callback (CACHEFILE cachefile, int fd, BLOCKNUM nodename, void *brtnode_v, void *extraargs, long size, BOOL write_me, BOOL keep_me, BOOL for_checkpoint);
 extern int toku_brtnode_fetch_callback (CACHEFILE cachefile, int fd, BLOCKNUM nodename, u_int32_t fullhash, void **brtnode_pv, long *sizep, int*dirty, void*extraargs);
 extern int toku_brtnode_pe_callback (void *brtnode_pv, long bytes_to_free, long* bytes_freed, void *extraargs);
+extern BOOL toku_brtnode_pf_req_callback(void* brtnode_pv, void* read_extraargs);
+extern int toku_brtnode_pf_callback(void* brtnode_pv, void* read_extraargs, long* sizep);
 extern int toku_brt_alloc_init_header(BRT t, TOKUTXN txn);
 extern int toku_read_brt_header_and_store_in_cachefile (CACHEFILE cf, LSN max_acceptable_lsn, struct brt_header **header, BOOL* was_open);
 extern CACHEKEY* toku_calculate_root_offset_pointer (BRT brt, u_int32_t *root_hash);

newbrt/brt-test-helpers.c

@@ -77,8 +77,19 @@ int toku_testsetup_get_sersize(BRT brt, BLOCKNUM diskoff) // Return the size on
 {
     assert(testsetup_initialized);
     void *node_v;
-    int r  = toku_cachetable_get_and_pin(brt->cf, diskoff, toku_cachetable_hash(brt->cf, diskoff), &node_v, NULL,
-					 toku_brtnode_flush_callback, toku_brtnode_fetch_callback, toku_brtnode_pe_callback, brt);
+    int r  = toku_cachetable_get_and_pin(
+        brt->cf, diskoff, 
+        toku_cachetable_hash(brt->cf, diskoff), 
+        &node_v, 
+        NULL,
+        toku_brtnode_flush_callback, 
+        toku_brtnode_fetch_callback, 
+        toku_brtnode_pe_callback, 
+        toku_brtnode_pf_req_callback,
+        toku_brtnode_pf_callback,
+        brt->h, 
+        brt->h
+        );
     assert(r==0);
     int size = toku_serialize_brtnode_size(node_v);
     toku_unpin_brtnode(brt, node_v);
@@ -91,8 +102,20 @@ int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM blocknum, char *key, int ke
 
     assert(testsetup_initialized);
     
-    r = toku_cachetable_get_and_pin(brt->cf, blocknum, toku_cachetable_hash(brt->cf, blocknum), &node_v, NULL,
-				    toku_brtnode_flush_callback, toku_brtnode_fetch_callback, toku_brtnode_pe_callback, brt);
+    r = toku_cachetable_get_and_pin(
+        brt->cf, 
+        blocknum, 
+        toku_cachetable_hash(brt->cf, blocknum), 
+        &node_v, 
+        NULL,
+	toku_brtnode_flush_callback, 
+	toku_brtnode_fetch_callback, 
+	toku_brtnode_pe_callback, 
+        toku_brtnode_pf_req_callback,
+        toku_brtnode_pf_callback,
+	brt->h, 
+	brt->h
+	);
     if (r!=0) return r;
     BRTNODE node=node_v;
     toku_verify_or_set_counts(node);
@@ -146,8 +169,20 @@ int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM blocknum, enum brt_msg_t
 
     assert(testsetup_initialized);
 
-    r = toku_cachetable_get_and_pin(brt->cf, blocknum, toku_cachetable_hash(brt->cf, blocknum), &node_v, NULL,
-				    toku_brtnode_flush_callback, toku_brtnode_fetch_callback, toku_brtnode_pe_callback, brt);
+    r = toku_cachetable_get_and_pin(
+        brt->cf, 
+        blocknum, 
+        toku_cachetable_hash(brt->cf, blocknum), 
+        &node_v, 
+        NULL,
+	toku_brtnode_flush_callback, 
+	toku_brtnode_fetch_callback, 
+	toku_brtnode_pe_callback, 
+        toku_brtnode_pf_req_callback,
+        toku_brtnode_pf_callback,
+	brt->h, 
+	brt->h
+	);
     if (r!=0) return r;
     BRTNODE node=node_v;
     assert(node->height>0);

newbrt/brt-verify.c

@@ -113,8 +113,20 @@ toku_verify_brtnode (BRT brt,
     
     u_int32_t fullhash = toku_cachetable_hash(brt->cf, blocknum);
     {
-        int r = toku_cachetable_get_and_pin(brt->cf, blocknum, fullhash, &node_v, NULL,
-                                            toku_brtnode_flush_callback, toku_brtnode_fetch_callback, toku_brtnode_pe_callback, brt->h);
+        int r = toku_cachetable_get_and_pin(
+            brt->cf, 
+            blocknum, 
+            fullhash, 
+            &node_v, 
+            NULL,
+            toku_brtnode_flush_callback, 
+            toku_brtnode_fetch_callback, 
+            toku_brtnode_pe_callback, 
+            toku_brtnode_pf_req_callback,
+            toku_brtnode_pf_callback,
+            brt->h, 
+            brt->h
+            );
         assert_zero(r); // this is a bad failure if it happens.
     }
     //printf("%s:%d pin %p\n", __FILE__, __LINE__, node_v);

newbrt/cachetable.h

@@ -114,16 +114,28 @@ int toku_cachefile_fsync(CACHEFILE cf);
 // When for_checkpoint is true, this was a 'pending' write
 // Returns: 0 if success, otherwise an error number.
 // Can access fd (fd is protected by a readlock during call)
-typedef void (*CACHETABLE_FLUSH_CALLBACK)(CACHEFILE, int fd, CACHEKEY key, void *value, void *extraargs, long size, BOOL write_me, BOOL keep_me, BOOL for_checkpoint);
+typedef void (*CACHETABLE_FLUSH_CALLBACK)(CACHEFILE, int fd, CACHEKEY key, void *value, void *write_extraargs, long size, BOOL write_me, BOOL keep_me, BOOL for_checkpoint);
 
 // The fetch callback is called when a thread is attempting to get and pin a memory
 // object and it is not in the cachetable.
 // Returns: 0 if success, otherwise an error number.  The address and size of the object
 // associated with the key are returned.
 // Can access fd (fd is protected by a readlock during call)
-typedef int (*CACHETABLE_FETCH_CALLBACK)(CACHEFILE, int fd, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, int *dirtyp, void *extraargs);
+typedef int (*CACHETABLE_FETCH_CALLBACK)(CACHEFILE, int fd, CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, int *dirtyp, void *read_extraargs);
 
-typedef int (*CACHETABLE_PARTIAL_EVICTION_CALLBACK)(void *brtnode_pv, long bytes_to_free, long* bytes_freed, void *extraargs);
+typedef int (*CACHETABLE_PARTIAL_EVICTION_CALLBACK)(void *brtnode_pv, long bytes_to_free, long* bytes_freed, void *write_extraargs);
+
+// This callback is called by the cachetable to ask if a partial fetch is required of brtnode_pv. If a partial fetch
+// is required, then CACHETABLE_PARTIAL_FETCH_CALLBACK is called (possibly with ydb lock released). The reason
+// this callback exists instead of just doing the same functionality in CACHETABLE_PARTIAL_FETCH_CALLBACK 
+// is so that we can call this cheap function with the ydb lock held, in the hopes of avoiding the more expensive sequence
+// of releasing the ydb lock, calling the partial_fetch_callback, reading nothing, reacquiring the ydb lock
+typedef BOOL (*CACHETABLE_PARTIAL_FETCH_REQUIRED_CALLBACK)(void *brtnode_pv, void *read_extraargs);
+
+// The partial fetch callback is called when a thread needs to read a subset of a PAIR into memory
+// Returns: 0 if success, otherwise an error number.  
+// The number of bytes added is returned in sizep
+typedef int (*CACHETABLE_PARTIAL_FETCH_CALLBACK)(void *brtnode_pv, void *read_extraargs, long *sizep);
 
 void toku_cachefile_set_userdata(CACHEFILE cf, void *userdata,
     int (*log_fassociate_during_checkpoint)(CACHEFILE, void*),
@@ -154,9 +166,8 @@ CACHETABLE toku_cachefile_get_cachetable(CACHEFILE cf);
 int toku_cachetable_put(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash,
 			void *value, long size,
 			CACHETABLE_FLUSH_CALLBACK flush_callback,
-                        CACHETABLE_FETCH_CALLBACK fetch_callback,
                         CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
-                        void *extraargs
+                        void *write_extraargs
                         );
 
 // Get and pin a memory object.
@@ -164,12 +175,20 @@ int toku_cachetable_put(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash,
 // Otherwise, fetch it from storage by calling the fetch callback.  If the fetch
 // succeeded, add the memory object to the cachetable with a read lock on it.
 // Returns: 0 if the memory object is in memory, otherwise an error number.
-int toku_cachetable_get_and_pin(CACHEFILE, CACHEKEY, u_int32_t /*fullhash*/,
-				void **/*value*/, long *sizep,
-				CACHETABLE_FLUSH_CALLBACK flush_callback,
-                                CACHETABLE_FETCH_CALLBACK fetch_callback, 
-                                CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
-                                void *extraargs);
+int toku_cachetable_get_and_pin (
+    CACHEFILE cachefile, 
+    CACHEKEY key, 
+    u_int32_t fullhash, 
+    void**value, 
+    long *sizep,
+    CACHETABLE_FLUSH_CALLBACK flush_callback, 
+    CACHETABLE_FETCH_CALLBACK fetch_callback, 
+    CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
+    CACHETABLE_PARTIAL_FETCH_REQUIRED_CALLBACK pf_req_callback  __attribute__((unused)),
+    CACHETABLE_PARTIAL_FETCH_CALLBACK pf_callback  __attribute__((unused)),
+    void* read_extraargs,
+    void* write_extraargs
+    );
 
 typedef struct unlockers *UNLOCKERS;
 struct unlockers {
@@ -182,12 +201,22 @@ struct unlockers {
 // Effect:  If the block is in the cachetable, then return it. 
 //   Otherwise call the release_lock_callback, call the functions in unlockers, fetch the data (but don't pin it, since we'll just end up pinning it again later),
 //   and return TOKU_DB_TRYAGAIN.
-int toku_cachetable_get_and_pin_nonblocking (CACHEFILE cachefile, CACHEKEY key, u_int32_t fullhash, void**value, long *sizep,
-					     CACHETABLE_FLUSH_CALLBACK flush_callback, 
-					     CACHETABLE_FETCH_CALLBACK fetch_callback, 
-                                             CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
-					     void *extraargs,
-					     UNLOCKERS unlockers);
+int toku_cachetable_get_and_pin_nonblocking (
+    CACHEFILE cf, 
+    CACHEKEY key, 
+    u_int32_t fullhash, 
+    void**value, 
+    long *sizep,
+    CACHETABLE_FLUSH_CALLBACK flush_callback, 
+    CACHETABLE_FETCH_CALLBACK fetch_callback, 
+    CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
+    CACHETABLE_PARTIAL_FETCH_REQUIRED_CALLBACK pf_req_callback  __attribute__((unused)),
+    CACHETABLE_PARTIAL_FETCH_CALLBACK pf_callback  __attribute__((unused)),
+    void *read_extraargs,
+    void* write_extraargs,
+    UNLOCKERS unlockers
+    );
+
 #define CAN_RELEASE_LOCK_DURING_IO
 
 int toku_cachetable_maybe_get_and_pin (CACHEFILE, CACHEKEY, u_int32_t /*fullhash*/, void**);
@@ -227,8 +256,11 @@ int toku_cachetable_unpin_and_remove (CACHEFILE, CACHEKEY); /* Removing somethin
 int toku_cachefile_prefetch(CACHEFILE cf, CACHEKEY key, u_int32_t fullhash,
                             CACHETABLE_FLUSH_CALLBACK flush_callback, 
                             CACHETABLE_FETCH_CALLBACK fetch_callback, 
-                            CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback, 
-                            void *extraargs);
+                            CACHETABLE_PARTIAL_EVICTION_CALLBACK pe_callback,
+                            CACHETABLE_PARTIAL_FETCH_REQUIRED_CALLBACK pf_req_callback  __attribute__((unused)),
+                            CACHETABLE_PARTIAL_FETCH_CALLBACK pf_callback  __attribute__((unused)),
+                            void *read_extraargs, 
+                            void *write_extraargs);
 // Effect: Prefetch a memory object for a given key into the cachetable
 // Precondition: The cachetable mutex is NOT held.
 // Postcondition: The cachetable mutex is NOT held.

newbrt/rollback.c

@@ -96,7 +96,7 @@ toku_apply_txn (TOKUTXN txn, YIELDF yield, void*yieldv, LSN lsn,
 
         r = toku_maybe_prefetch_older_rollback_log(txn, log);
         assert(r==0);
-
+        
         last_sequence = log->sequence;
         if (func) {
             while ((item=log->newest_logentry)) {
@@ -523,6 +523,14 @@ static int toku_rollback_pe_callback (
     *bytes_freed = 0;
     return 0;
 }
+static BOOL toku_rollback_pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int toku_rollback_pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    // should never be called, given that toku_rollback_pf_req_callback always returns false
+    assert(FALSE);
+}
 
 
 
@@ -553,7 +561,6 @@ static int toku_create_new_rollback_log (TOKUTXN txn, BLOCKNUM older, uint32_t o
     r=toku_cachetable_put(cf, log->thislogname, log->thishash,
                           log, rollback_memory_size(log),
                           toku_rollback_flush_callback, 
-                          toku_rollback_fetch_callback,
                           toku_rollback_pe_callback,
                           h);
     assert(r==0);
@@ -760,6 +767,7 @@ int toku_txn_find_by_xid (BRT brt, TXNID xid, TOKUTXN *txnptr) {
 int
 toku_maybe_prefetch_older_rollback_log(TOKUTXN txn, ROLLBACK_LOG_NODE log) {
     //Currently processing 'log'.  Prefetch the next (older) log node.
+
     BLOCKNUM name = log->older;
     int r = 0;
     if (name.b != ROLLBACK_NONE.b) {
@@ -770,6 +778,9 @@ toku_maybe_prefetch_older_rollback_log(TOKUTXN txn, ROLLBACK_LOG_NODE log) {
                                     toku_rollback_flush_callback,
                                     toku_rollback_fetch_callback,
                                     toku_rollback_pe_callback,
+                                    toku_brtnode_pf_req_callback,
+                                    toku_brtnode_pf_callback,
+                                    h,
                                     h);
         assert(r==0);
     }
@@ -796,6 +807,9 @@ int toku_get_and_pin_rollback_log(TOKUTXN txn, TXNID xid, uint64_t sequence, BLO
                                         toku_rollback_flush_callback, 
                                         toku_rollback_fetch_callback,
                                         toku_rollback_pe_callback,
+                                        toku_rollback_pf_req_callback,
+                                        toku_rollback_pf_callback,
+                                        h,
                                         h);
         assert(r==0);
         log = (ROLLBACK_LOG_NODE)log_v;

newbrt/tests/cachetable-all-write.c

@@ -47,6 +47,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void
 cachetable_test (void) {
@@ -62,11 +70,11 @@ cachetable_test (void) {
     void* v1;
     void* v2;
     long s1, s2;
-    r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, NULL);
+    r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
     r = toku_cachetable_unpin(f1, make_blocknum(1), 1, CACHETABLE_DIRTY, 8);
-    r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, NULL);
+    r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
     // usleep (2*1024*1024);
-    //r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, NULL);
+    //r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL);
 
 
     r = toku_cachetable_unpin(f1, make_blocknum(2), 2, CACHETABLE_CLEAN, 8);

newbrt/tests/cachetable-checkpoint-pending.c

@@ -64,6 +64,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    // placeholder for now
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
 
 static void*
 do_update (void *UU(ignore))
@@ -75,7 +83,7 @@ do_update (void *UU(ignore))
         u_int32_t hi = toku_cachetable_hash(cf, key);
         void *vv;
 	long size;
-        int r = toku_cachetable_get_and_pin(cf, key, hi, &vv, &size, flush, fetch, pe_callback, 0);
+        int r = toku_cachetable_get_and_pin(cf, key, hi, &vv, &size, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
 	//printf("g");
 	assert(r==0);
 	assert(size==sizeof(int));
@@ -124,7 +132,7 @@ static void checkpoint_pending(void) {
         CACHEKEY key = make_blocknum(i);
         u_int32_t hi = toku_cachetable_hash(cf, key);
 	values[i] = 42;
-        r = toku_cachetable_put(cf, key, hi, &values[i], sizeof(int), flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(cf, key, hi, &values[i], sizeof(int), flush, pe_callback, 0);
         assert(r == 0);
 
         r = toku_cachetable_unpin(cf, key, hi, CACHETABLE_DIRTY, item_size);

newbrt/tests/cachetable-checkpoint-test.c

@@ -19,16 +19,6 @@ static void flush(CACHEFILE cf, int UU(fd), CACHEKEY key, void *value, void *ext
     if (keep_me) n_keep_me++;
 }
 
-static int fetch(CACHEFILE cf, int UU(fd), CACHEKEY key, u_int32_t fullhash, void **value, long *sizep, int *dirtyp, void *extraargs) {
-    cf = cf; key = key; fullhash = fullhash; value = value; sizep = sizep; extraargs = extraargs;
-    assert(0); // should not be called
-    n_fetch++;
-    *value = 0;
-    *sizep = item_size;
-    *dirtyp = 0;
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -82,7 +72,7 @@ static void cachetable_checkpoint_test(int n, enum cachetable_dirty dirty) {
     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, pe_callback, 0);
+        r = toku_cachetable_put(f1, key, hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
 
         r = toku_cachetable_unpin(f1, key, hi, dirty, item_size);

newbrt/tests/cachetable-clock-eviction.c

@@ -43,22 +43,6 @@ fetch (CACHEFILE f        __attribute__((__unused__)),
     return 0;
 }
 
-static int
-big_fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp,
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    *dirtyp = 0;
-    *value = NULL;
-    *sizep = 4;
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -71,6 +55,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
+
 
 static void
 cachetable_test (void) {
@@ -90,24 +82,24 @@ cachetable_test (void) {
     flush_may_occur = FALSE;
     check_flush = TRUE;
     for (int i = 0; i < 100000; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(1), 1, CACHETABLE_CLEAN, 1);
     }
     for (int i = 0; i < 8; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(2), 2, CACHETABLE_CLEAN, 1);
     }
     for (int i = 0; i < 4; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(3), 3, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(3), 3, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(3), 3, CACHETABLE_CLEAN, 1);
     }
     for (int i = 0; i < 2; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(4), 4, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(4), 4, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(4), 4, CACHETABLE_CLEAN, 1);
     }
     flush_may_occur = TRUE;
     expected_flushed_key = 4;
-    r = toku_cachetable_put(f1, make_blocknum(5), 5, NULL, 4, flush, big_fetch, pe_callback, NULL);
+    r = toku_cachetable_put(f1, make_blocknum(5), 5, NULL, 4, flush, pe_callback, NULL);
     flush_may_occur = TRUE;
     expected_flushed_key = 5;
     r = toku_cachetable_unpin(f1, make_blocknum(5), 5, CACHETABLE_CLEAN, 4);

newbrt/tests/cachetable-clock-eviction2.c

@@ -54,20 +54,6 @@ other_flush (CACHEFILE f __attribute__((__unused__)),
        ) {
 }
 
-static int
-other_fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp,
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    *dirtyp = 0;
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv, 
@@ -95,6 +81,13 @@ other_pe_callback (
 {
     return 0;
 }
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
 
 
 static void
@@ -113,24 +106,24 @@ cachetable_test (void) {
     long s1, s2;
     flush_may_occur = FALSE;
     for (int i = 0; i < 100000; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(1), 1, CACHETABLE_CLEAN, 4);
     }
     for (int i = 0; i < 8; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(2), 2, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(2), 2, CACHETABLE_CLEAN, 4);
     }
     for (int i = 0; i < 4; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(3), 3, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(3), 3, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(3), 3, CACHETABLE_CLEAN, 4);
     }
     for (int i = 0; i < 2; i++) {
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(4), 4, &v2, &s2, flush, fetch, pe_callback, NULL);
+      r = toku_cachetable_get_and_pin(f1, make_blocknum(4), 4, &v2, &s2, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
         r = toku_cachetable_unpin(f1, make_blocknum(4), 4, CACHETABLE_CLEAN, 4);
     }
     flush_may_occur = FALSE;
     expected_bytes_to_free = 4;
-    r = toku_cachetable_put(f1, make_blocknum(5), 5, NULL, 4, other_flush, other_fetch, other_pe_callback, NULL);
+    r = toku_cachetable_put(f1, make_blocknum(5), 5, NULL, 4, other_flush, other_pe_callback, NULL);
     flush_may_occur = TRUE;
     r = toku_cachetable_unpin(f1, make_blocknum(5), 5, CACHETABLE_CLEAN, 4);
 

newbrt/tests/cachetable-count-pinned-test.c

@@ -15,19 +15,6 @@ flush (CACHEFILE f __attribute__((__unused__)),
     /* Do nothing */
 }
 
-static int
-fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp       __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -56,7 +43,7 @@ cachetable_count_pinned_test (int n) {
     for (i=1; i<=n; i++) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         assert(toku_cachefile_count_pinned(f1, 0) == i);
 

newbrt/tests/cachetable-debug-test.c

@@ -15,19 +15,6 @@ flush (CACHEFILE f __attribute__((__unused__)),
     /* Do nothing */
 }
 
-static int
-fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp       __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -64,7 +51,7 @@ cachetable_debug_test (int n) {
         const int item_size = 1;
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, item_size, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, item_size, flush, pe_callback, 0);
         assert(r == 0);
 
         void *v; int dirty; long long pinned; long pair_size;

newbrt/tests/cachetable-flush-test.c

@@ -15,19 +15,6 @@ flush (CACHEFILE f __attribute__((__unused__)),
     /* Do nothing */
 }
 
-static int
-fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp       __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -40,7 +27,6 @@ pe_callback (
     return 0;
 }
 
-
 static void
 test_cachetable_flush (int n) {
     const int test_limit = 2*n;
@@ -62,12 +48,12 @@ test_cachetable_flush (int n) {
     for (i=0; i<n; i++) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         r = toku_cachetable_unpin(f1, make_blocknum(i), hi, CACHETABLE_CLEAN, 1);
         assert(r == 0);
         hi = toku_cachetable_hash(f2, make_blocknum(i));
-        r = toku_cachetable_put(f2, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f2, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         r = toku_cachetable_unpin(f2, make_blocknum(i), hi, CACHETABLE_CLEAN, 1);
         assert(r == 0);

newbrt/tests/cachetable-getandpin-test.c

@@ -49,6 +49,13 @@ pe_callback (
     *bytes_freed = 0;
     return 0;
 }
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
 
 
 static void
@@ -69,7 +76,7 @@ cachetable_getandpin_test (int n) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
         void *v; long size;
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(i), hi, &v, &size, flush, fetch_error, pe_callback, 0);
+        r = toku_cachetable_get_and_pin(f1, make_blocknum(i), hi, &v, &size, flush, fetch_error, pe_callback, pf_req_callback, pf_callback, 0, 0);
         assert(r == -1);
     }
 
@@ -78,7 +85,7 @@ cachetable_getandpin_test (int n) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
         void *v; long size;
-        r = toku_cachetable_get_and_pin(f1, make_blocknum(i), hi, &v, &size, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_get_and_pin(f1, make_blocknum(i), hi, &v, &size, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
         assert(r == 0);
         assert(size == i);
 

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

@@ -44,6 +44,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 static int dummy_pin_unpin(CACHEFILE UU(cfu), void* UU(v)) {
     return 0;
 }
@@ -66,7 +74,7 @@ static void cachetable_prefetch_checkpoint_test(int n, enum cachetable_dirty dir
     {
         CACHEKEY key = make_blocknum(n+1);
         u_int32_t fullhash = toku_cachetable_hash(f1, key);
-        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, 0);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
         toku_cachetable_verify(ct);
     }
 
@@ -75,7 +83,7 @@ static void cachetable_prefetch_checkpoint_test(int n, enum cachetable_dirty dir
     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, pe_callback, 0);
+        r = toku_cachetable_put(f1, key, hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
 
         r = toku_cachetable_unpin(f1, key, hi, dirty, item_size);

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

@@ -53,6 +53,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 static void cachetable_prefetch_maybegetandpin_test (void) {
     const int test_limit = 1;
     int r;
@@ -66,7 +74,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // close with the prefetch in progress. the close should block until

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

@@ -54,6 +54,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 static void cachetable_prefetch_close_leak_test (void) {
     const int test_limit = 1;
     int r;
@@ -67,7 +75,7 @@ static void cachetable_prefetch_close_leak_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // close with the prefetch in progress. the close should block until

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

@@ -53,6 +53,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void cachetable_prefetch_maybegetandpin_test (void) {
     const int test_limit = 1;
@@ -67,7 +75,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // close with the prefetch in progress. the close should block until

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

@@ -65,6 +65,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 // Note: cachetable_size_limit must be a power of 2
 static void cachetable_prefetch_flowcontrol_test (int cachetable_size_limit) {
@@ -82,7 +90,7 @@ static void cachetable_prefetch_flowcontrol_test (int cachetable_size_limit) {
     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, pe_callback, 0);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
         toku_cachetable_verify(ct);
     }
 
@@ -93,7 +101,7 @@ static void cachetable_prefetch_flowcontrol_test (int cachetable_size_limit) {
     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, pe_callback, 0);
+        r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
         toku_cachetable_verify(ct);
 	// sleep(1);
     }

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

@@ -49,6 +49,13 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
 
 static uint64_t tdelta_usec(struct timeval *tend, struct timeval *tstart) {
     uint64_t t = tend->tv_sec * 1000000 + tend->tv_usec;
@@ -72,13 +79,13 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 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, pe_callback, NULL);
+    r = toku_cachetable_get_and_pin(f1, key, fullhash, &v, &size, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
     assert(r != 0);
 
     struct timeval tend; 

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

@@ -50,6 +50,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 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;
@@ -72,13 +80,13 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 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, pe_callback, NULL);
+    r = toku_cachetable_get_and_pin(f1, key, fullhash, &v, &size, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
     assert(r == 0 && v == 0 && size == 1);
 
     struct timeval tend; 

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

@@ -49,6 +49,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void cachetable_prefetch_maybegetandpin_test (void) {
     const int test_limit = 1;
@@ -63,7 +71,7 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // verify that maybe_get_and_pin returns an error while the prefetch is in progress

newbrt/tests/cachetable-prefetch2-test.c

@@ -53,6 +53,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void cachetable_prefetch_maybegetandpin_test (void) {
     const int test_limit = 1;
@@ -67,11 +75,11 @@ static void cachetable_prefetch_maybegetandpin_test (void) {
     // 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, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // prefetch again. this should do nothing.
-    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, 0);
+    r = toku_cachefile_prefetch(f1, key, fullhash, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     toku_cachetable_verify(ct);
 
     // verify that maybe_get_and_pin returns an error while the prefetch is in progress

newbrt/tests/cachetable-put-test.c

@@ -15,20 +15,6 @@ flush (CACHEFILE f __attribute__((__unused__)),
     /* Do nothing */
 }
 
-static int
-fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp       __attribute__((__unused__)),
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    *dirtyp = 0;
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -57,11 +43,11 @@ cachetable_put_test (int n) {
     for (i=1; i<=n; i++) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         assert(toku_cachefile_count_pinned(f1, 0) == i);
 
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == -1);
         assert(toku_cachefile_count_pinned(f1, 0) == i);
         

newbrt/tests/cachetable-rename-test.c

@@ -91,6 +91,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void test_rename (void) {
     CACHETABLE t;
@@ -113,7 +121,7 @@ static void test_rename (void) {
 	    u_int32_t hnkey = toku_cachetable_hash(f, nkey);
 	    r = toku_cachetable_put(f, nkey, hnkey,
 				    (void*)nval, 1,
-				    r_flush, r_fetch, pe_callback, 0);
+				    r_flush, pe_callback, 0);
 	    assert(r==0);
             test_mutex_lock();
             while (n_keys >= KEYLIMIT) {
@@ -138,7 +146,7 @@ static void test_rename (void) {
 	    void *current_value;
 	    long current_size;
 	    if (verbose) printf("Rename %" PRIx64 " to %" PRIx64 "\n", okey.b, nkey.b);
-	    r = toku_cachetable_get_and_pin(f, okey, toku_cachetable_hash(f, okey), &current_value, &current_size, r_flush, r_fetch, pe_callback, 0);
+	    r = toku_cachetable_get_and_pin(f, okey, toku_cachetable_hash(f, okey), &current_value, &current_size, r_flush, r_fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
 	    if (r == -42) continue;
             assert(r==0);
 	    r = toku_cachetable_rename(f, okey, nkey);

newbrt/tests/cachetable-scan.c

@@ -56,6 +56,14 @@ pe_callback (
     *bytes_freed = 0;
     return 0;
 }
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
+
 
 
 const char fname[] = __FILE__ ".dat";
@@ -79,7 +87,7 @@ static void writeit (void) {
 	u_int32_t fullhash = toku_cachetable_hash(f, key);
 	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, pe_callback, 0);	assert(r==0);
+	r = toku_cachetable_put(f, key, fullhash, buf, BLOCKSIZE, f_flush, pe_callback, 0);	assert(r==0);
 	r = toku_cachetable_unpin(f, key, fullhash, CACHETABLE_CLEAN, BLOCKSIZE); assert(r==0);
     }
     gettimeofday(&end, 0);
@@ -100,7 +108,7 @@ static void readit (void) {
     for (i=0; i<N; i++) {
 	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, pe_callback, 0); assert(r==0);
+	r=toku_cachetable_get_and_pin(f, key, fullhash, &block, &current_size, f_flush, f_fetch, pe_callback, pf_req_callback, pf_callback, 0, 0); assert(r==0);
 	r=toku_cachetable_unpin(f, key, fullhash, CACHETABLE_CLEAN, BLOCKSIZE);                                      assert(r==0);
     }
     r = toku_cachefile_close(&f, 0, FALSE, ZERO_LSN);    assert(r == 0);

newbrt/tests/cachetable-simple-verify.c

@@ -45,6 +45,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
+
 
 static void
 cachetable_test (void) {
@@ -61,7 +69,7 @@ cachetable_test (void) {
   //void* v2;
   long s1;
   //long s2;
-  r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, NULL);
+  r = toku_cachetable_get_and_pin(f1, make_blocknum(1), 1, &v1, &s1, flush, fetch, pe_callback, pf_req_callback, pf_callback, NULL, NULL);
   r = toku_cachetable_unpin(f1, make_blocknum(1), 1, CACHETABLE_DIRTY, 8);
   toku_cachetable_verify(ct);
   r = toku_cachefile_close(&f1, 0, FALSE, ZERO_LSN); assert(r == 0 && f1 == 0);

newbrt/tests/cachetable-test2.c

@@ -130,6 +130,14 @@ pe_callback (
     return 0;
 }
 
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+    return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+    assert(FALSE);
+}
+
 
 static void verify_cachetable_against_present (void) {
     int i;
@@ -174,7 +182,7 @@ static void test_chaining (void) {
 	int fnum = i%N_FILES;
 	//printf("%s:%d Add %d\n", __FILE__, __LINE__, i);
 	u_int32_t fhash = toku_cachetable_hash(f[fnum], make_blocknum(i));
-	r = toku_cachetable_put(f[fnum], make_blocknum(i), fhash, (void*)i, test_object_size, flush_forchain, fetch_forchain, pe_callback, (void*)i);
+	r = toku_cachetable_put(f[fnum], make_blocknum(i), fhash, (void*)i, test_object_size, flush_forchain, pe_callback, (void*)i);
 	assert(r==0);
 	item_becomes_present(ct, f[fnum], make_blocknum(i));
 	r = toku_cachetable_unpin(f[fnum], make_blocknum(i), fhash, CACHETABLE_CLEAN, test_object_size);
@@ -203,7 +211,10 @@ static void test_chaining (void) {
 					    flush_forchain,
 					    fetch_forchain,
 					    pe_callback,
-					    (void*)(long)whichkey.b
+					    pf_req_callback,
+					    pf_callback,
+					    (void*)(long)whichkey.b,
+                                            (void*)(long)whichkey.b
 					    );
 	    assert(r==0);
 	    r = toku_cachetable_unpin(whichcf,
@@ -219,7 +230,7 @@ static void test_chaining (void) {
         // if i is a duplicate, cachetable_put will return -1
 	// printf("%s:%d Add {%ld,%p}\n", __FILE__, __LINE__, i, f[fnum]);
 	u_int32_t fhash = toku_cachetable_hash(f[fnum], make_blocknum(i));
-	r = toku_cachetable_put(f[fnum], make_blocknum(i), fhash, (void*)i, test_object_size, flush_forchain, fetch_forchain, pe_callback, (void*)i);
+	r = toku_cachetable_put(f[fnum], make_blocknum(i), fhash, (void*)i, test_object_size, flush_forchain, pe_callback, (void*)i);
         assert(r==0 || r==-1);
         if (r==0) {
             item_becomes_present(ct, f[fnum], make_blocknum(i));

newbrt/tests/cachetable-unpin-and-remove-test.c

@@ -40,6 +40,14 @@ pe_callback (
     *bytes_freed = 0;
     return 0;
 }
+static BOOL pf_req_callback(void* UU(brtnode_pv), void* UU(read_extraargs)) {
+  return FALSE;
+}
+
+static int pf_callback(void* UU(brtnode_pv), void* UU(read_extraargs), long* UU(sizep)) {
+  assert(FALSE);
+}
+
 
 
 // test simple unpin and remove
@@ -66,7 +74,7 @@ cachetable_unpin_and_remove_test (int n) {
     // put the keys into the cachetable
     for (i=0; i<n; i++) {
         u_int32_t hi = toku_cachetable_hash(f1, make_blocknum(keys[i].b));
-        r = toku_cachetable_put(f1, make_blocknum(keys[i].b), hi, (void *)(long) keys[i].b, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(keys[i].b), hi, (void *)(long) keys[i].b, 1, flush, pe_callback, 0);
         assert(r == 0);
     }
     
@@ -127,7 +135,7 @@ cachetable_put_evict_remove_test (int n) {
 
     // put 0, 1, 2, ... should evict 0
     for (i=0; i<n; i++) {
-        r = toku_cachetable_put(f1, make_blocknum(i), hi[i], (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi[i], (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         r = toku_cachetable_unpin(f1, make_blocknum(i), hi[i], CACHETABLE_CLEAN, 1);
         assert(r == 0);
@@ -135,7 +143,7 @@ cachetable_put_evict_remove_test (int n) {
 
     // get 0
     void *v; long s;
-    r = toku_cachetable_get_and_pin(f1, make_blocknum(0), hi[0], &v, &s, flush, fetch, pe_callback, 0);
+    r = toku_cachetable_get_and_pin(f1, make_blocknum(0), hi[0], &v, &s, flush, fetch, pe_callback, pf_req_callback, pf_callback, 0, 0);
     assert(r == 0);
         
     // remove 0

newbrt/tests/cachetable-unpin-test.c

@@ -15,20 +15,6 @@ flush (CACHEFILE f __attribute__((__unused__)),
     /* Do nothing */
 }
 
-static int
-fetch (CACHEFILE f        __attribute__((__unused__)),
-       int UU(fd),
-       CACHEKEY k         __attribute__((__unused__)),
-       u_int32_t fullhash __attribute__((__unused__)),
-       void **value       __attribute__((__unused__)),
-       long *sizep        __attribute__((__unused__)),
-       int  *dirtyp,
-       void *extraargs    __attribute__((__unused__))
-       ) {
-    *dirtyp = 0;
-    return 0;
-}
-
 static int 
 pe_callback (
     void *brtnode_pv __attribute__((__unused__)), 
@@ -57,7 +43,7 @@ cachetable_unpin_test (int n) {
     for (i=1; i<=n; i++) {
         u_int32_t hi;
         hi = toku_cachetable_hash(f1, make_blocknum(i));
-        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, fetch, pe_callback, 0);
+        r = toku_cachetable_put(f1, make_blocknum(i), hi, (void *)(long)i, 1, flush, pe_callback, 0);
         assert(r == 0);
         assert(toku_cachefile_count_pinned(f1, 0) == i);