Renamed 'toku_pin_ftnode_off_client_thread' to 'toku_pin_ftnode_with_dep_nodes'

ft/ft-cachetable-wrappers.cc

@@ -317,7 +317,7 @@ toku_pin_ftnode(
 }
 
 void
-toku_pin_ftnode_off_client_thread(
+toku_pin_ftnode_with_dep_nodes(
     FT h,
     BLOCKNUM blocknum,
     uint32_t fullhash,

ft/ft-cachetable-wrappers.h

@@ -160,7 +160,7 @@ toku_pin_ftnode(
  * Unlike toku_pin_ftnode, this function blocks until the node is pinned.
  */
 void
-toku_pin_ftnode_off_client_thread(
+toku_pin_ftnode_with_dep_nodes(
     FT h,
     BLOCKNUM blocknum,
     uint32_t fullhash,

ft/ft-flusher.cc

@@ -496,7 +496,7 @@ ct_maybe_merge_child(struct flusher_advice *fa,
             toku_calculate_root_offset_pointer(h, &root, &fullhash);
             struct ftnode_fetch_extra bfe;
             fill_bfe_for_full_read(&bfe, h);
-            toku_pin_ftnode_off_client_thread(h, root, fullhash, &bfe, PL_WRITE_EXPENSIVE, 0, NULL, &root_node, true);
+            toku_pin_ftnode_with_dep_nodes(h, root, fullhash, &bfe, PL_WRITE_EXPENSIVE, 0, NULL, &root_node, true);
             toku_assert_entire_node_in_memory(root_node);
         }
 
@@ -1426,7 +1426,7 @@ ft_merge_child(
         uint32_t childfullhash = compute_child_fullhash(h->cf, node, childnuma);
         struct ftnode_fetch_extra bfe;
         fill_bfe_for_full_read(&bfe, h);
-        toku_pin_ftnode_off_client_thread(h, BP_BLOCKNUM(node, childnuma), childfullhash, &bfe, PL_WRITE_EXPENSIVE, 1, &node, &childa, true);
+        toku_pin_ftnode_with_dep_nodes(h, BP_BLOCKNUM(node, childnuma), childfullhash, &bfe, PL_WRITE_EXPENSIVE, 1, &node, &childa, true);
     }
     // for test
     call_flusher_thread_callback(flt_flush_before_pin_second_node_for_merge);
@@ -1437,7 +1437,7 @@ ft_merge_child(
         uint32_t childfullhash = compute_child_fullhash(h->cf, node, childnumb);
         struct ftnode_fetch_extra bfe;
         fill_bfe_for_full_read(&bfe, h);
-        toku_pin_ftnode_off_client_thread(h, BP_BLOCKNUM(node, childnumb), childfullhash, &bfe, PL_WRITE_EXPENSIVE, 2, dep_nodes, &childb, true);
+        toku_pin_ftnode_with_dep_nodes(h, BP_BLOCKNUM(node, childnumb), childfullhash, &bfe, PL_WRITE_EXPENSIVE, 2, dep_nodes, &childb, true);
     }
 
     if (toku_bnc_n_entries(BNC(node,childnuma))>0) {
@@ -1575,7 +1575,7 @@ void toku_ft_flush_some_child(FT ft, FTNODE parent, struct flusher_advice *fa)
     // Note that we don't read the entire node into memory yet.
     // The idea is let's try to do the minimum work before releasing the parent lock
     fill_bfe_for_min_read(&bfe, ft);
-    toku_pin_ftnode_off_client_thread(ft, targetchild, childfullhash, &bfe, PL_WRITE_EXPENSIVE, 1, &parent, &child, true);
+    toku_pin_ftnode_with_dep_nodes(ft, targetchild, childfullhash, &bfe, PL_WRITE_EXPENSIVE, 1, &parent, &child, true);
 
     // for test
     call_flusher_thread_callback(ft_flush_aflter_child_pin);

ft/ft-hot-flusher.cc

@@ -332,7 +332,7 @@ toku_ft_hot_optimize(FT_HANDLE brt, DBT* left, DBT* right,
             toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
             struct ftnode_fetch_extra bfe;
             fill_bfe_for_full_read(&bfe, brt->ft);
-            toku_pin_ftnode_off_client_thread(brt->ft,
+            toku_pin_ftnode_with_dep_nodes(brt->ft,
                                                (BLOCKNUM) root_key,
                                                fullhash,
                                                &bfe,

ft/ft-ops.cc

@@ -1674,7 +1674,7 @@ ft_init_new_root(FT ft, FTNODE oldroot, FTNODE *newrootp)
     // return to caller
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_full_read(&bfe, ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_nodes(
         ft,
         old_blocknum,
         old_fullhash,
@@ -2793,7 +2793,7 @@ static bool process_maybe_reactive_child(FT ft, FTNODE parent, FTNODE child, int
             struct ftnode_fetch_extra bfe;
             fill_bfe_for_full_read(&bfe, ft);
             FTNODE newparent, newchild;
-            toku_pin_ftnode_off_client_thread(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent, true);
+            toku_pin_ftnode_with_dep_nodes(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent, true);
             if (newparent->height != parent_height || newparent->n_children != parent_n_children ||
                 childnum >= newparent->n_children || toku_bnc_n_entries(BNC(newparent, childnum))) {
                 // If the height changed or childnum is now off the end, something clearly got split or merged out from under us.
@@ -2807,7 +2807,7 @@ static bool process_maybe_reactive_child(FT ft, FTNODE parent, FTNODE child, int
             // and split it.
             child_blocknum = BP_BLOCKNUM(newparent, childnum);
             child_fullhash = compute_child_fullhash(ft->cf, newparent, childnum);
-            toku_pin_ftnode_off_client_thread(ft, child_blocknum, child_fullhash, &bfe, PL_WRITE_CHEAP, 1, &newparent, &newchild, true);
+            toku_pin_ftnode_with_dep_nodes(ft, child_blocknum, child_fullhash, &bfe, PL_WRITE_CHEAP, 1, &newparent, &newchild, true);
             newre = get_node_reactivity(ft, newchild);
             if (newre == RE_FISSIBLE) {
                 enum split_mode split_mode;
@@ -2845,7 +2845,7 @@ static bool process_maybe_reactive_child(FT ft, FTNODE parent, FTNODE child, int
             struct ftnode_fetch_extra bfe;
             fill_bfe_for_full_read(&bfe, ft);
             FTNODE newparent, newchild;
-            toku_pin_ftnode_off_client_thread(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent, true);
+            toku_pin_ftnode_with_dep_nodes(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent, true);
             if (newparent->height != parent_height || childnum >= newparent->n_children) {
                 // looks like this is the root and it got merged, let's just start over (like in the split case above)
                 toku_unpin_ftnode_read_only(ft, newparent);
@@ -2853,7 +2853,7 @@ static bool process_maybe_reactive_child(FT ft, FTNODE parent, FTNODE child, int
             }
             child_blocknum = BP_BLOCKNUM(newparent, childnum);
             child_fullhash = compute_child_fullhash(ft->cf, newparent, childnum);
-            toku_pin_ftnode_off_client_thread(ft, child_blocknum, child_fullhash, &bfe, PL_READ, 1, &newparent, &newchild, true);
+            toku_pin_ftnode_with_dep_nodes(ft, child_blocknum, child_fullhash, &bfe, PL_READ, 1, &newparent, &newchild, true);
             newre = get_node_reactivity(ft, newchild);
             if (newre == RE_FUSIBLE && newparent->n_children >= 2) {
                 toku_unpin_ftnode_read_only(ft, newchild);
@@ -2886,7 +2886,7 @@ static void inject_message_at_this_blocknum(FT ft, CACHEKEY cachekey, uint32_t f
     FTNODE node;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_full_read(&bfe, ft);
-    toku_pin_ftnode_off_client_thread(ft, cachekey, fullhash, &bfe, PL_WRITE_CHEAP, 0, NULL, &node, true);
+    toku_pin_ftnode_with_dep_nodes(ft, cachekey, fullhash, &bfe, PL_WRITE_CHEAP, 0, NULL, &node, true);
     toku_assert_entire_node_in_memory(node);
     paranoid_invariant(node->fullhash==fullhash);
     ft_verify_flags(ft, node);
@@ -3009,11 +3009,11 @@ static void push_something_in_subtree(
                     if (lock_type == PL_WRITE_CHEAP) {
                         // We intend to take the write lock for message injection
                         toku::context inject_ctx(CTX_MESSAGE_INJECTION);
-                        toku_pin_ftnode_off_client_thread(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child, true);
+                        toku_pin_ftnode_with_dep_nodes(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child, true);
                     } else {
                         // We're going to keep promoting
                         toku::context promo_ctx(CTX_PROMO);
-                        toku_pin_ftnode_off_client_thread(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child, true);
+                        toku_pin_ftnode_with_dep_nodes(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child, true);
                     }
                 } else {
                     r = toku_maybe_pin_ftnode_clean(ft, child_blocknum, child_fullhash, lock_type, &child);
@@ -3046,7 +3046,7 @@ static void push_something_in_subtree(
                     FTNODE newparent;
                     struct ftnode_fetch_extra bfe;
                     fill_bfe_for_full_read(&bfe, ft); // should be fully in memory, we just split it
-                    toku_pin_ftnode_off_client_thread(ft, subtree_root_blocknum, subtree_root_fullhash, &bfe, PL_READ, 0, nullptr, &newparent, true);
+                    toku_pin_ftnode_with_dep_nodes(ft, subtree_root_blocknum, subtree_root_fullhash, &bfe, PL_READ, 0, nullptr, &newparent, true);
                     push_something_in_subtree(ft, newparent, -1, msg, flow_deltas, gc_info, depth, loc, true);
                     return;
                 }
@@ -3143,7 +3143,7 @@ void toku_ft_root_put_msg(
     // and jump back to here.
  change_lock_type:
     // get the root node
-    toku_pin_ftnode_off_client_thread(ft, root_key, fullhash, &bfe, lock_type, 0, NULL, &node, true);
+    toku_pin_ftnode_with_dep_nodes(ft, root_key, fullhash, &bfe, lock_type, 0, NULL, &node, true);
     toku_assert_entire_node_in_memory(node);
     paranoid_invariant(node->fullhash==fullhash);
     ft_verify_flags(ft, node);
@@ -5434,8 +5434,8 @@ toku_ft_search (FT_HANDLE brt, ft_search_t *search, FT_GET_CALLBACK_FUNCTION get
     // the appropriate partition of the child we are using is in memory.
     // So, here are the steps for a search (and this applies to this function
     // as well as ft_search_child:
-    //  - Take the search parameter, and create a ftnode_fetch_extra, that will be used by toku_pin_ftnode(_holding_lock)
-    //  - Call toku_pin_ftnode(_holding_lock) with the bfe as the extra for the fetch callback (in case the node is not at all in memory)
+    //  - Take the search parameter, and create a ftnode_fetch_extra, that will be used by toku_pin_ftnode
+    //  - Call toku_pin_ftnode with the bfe as the extra for the fetch callback (in case the node is not at all in memory)
     //       and the partial fetch callback (in case the node is perhaps partially in memory) to the fetch the node
     //  - This eventually calls either toku_ftnode_fetch_callback or  toku_ftnode_pf_req_callback depending on whether the node is in
     //     memory at all or not.
@@ -5466,7 +5466,7 @@ toku_ft_search (FT_HANDLE brt, ft_search_t *search, FT_GET_CALLBACK_FUNCTION get
         uint32_t fullhash;
         CACHEKEY root_key;
         toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_nodes(
             ft,
             root_key,
             fullhash,
@@ -6089,7 +6089,7 @@ void toku_ft_keysrange(FT_HANDLE brt, DBT* key_left, DBT* key_right, uint64_t *l
             uint32_t fullhash;
             CACHEKEY root_key;
             toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
-            toku_pin_ftnode_off_client_thread(
+            toku_pin_ftnode_with_dep_nodes(
                 brt->ft,
                 root_key,
                 fullhash,
@@ -6308,7 +6308,7 @@ int toku_ft_get_key_after_bytes(FT_HANDLE ft_h, const DBT *start_key, uint64_t s
             uint32_t fullhash;
             CACHEKEY root_key;
             toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
-            toku_pin_ftnode_off_client_thread(ft, root_key, fullhash, &bfe, PL_READ, 0, nullptr, &root, true);
+            toku_pin_ftnode_with_dep_nodes(ft, root_key, fullhash, &bfe, PL_READ, 0, nullptr, &root, true);
         }
         struct unlock_ftnode_extra unlock_extra = {ft_h, root, false};
         struct unlockers unlockers = {true, unlock_ftnode_fun, (void*)&unlock_extra, (UNLOCKERS) nullptr};
@@ -6366,7 +6366,7 @@ toku_dump_ftnode (FILE *file, FT_HANDLE brt, BLOCKNUM blocknum, int depth, const
     uint32_t fullhash = toku_cachetable_hash(brt->ft->cf, blocknum);
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_full_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_nodes(
         brt->ft,
         blocknum,
         fullhash,
@@ -6567,7 +6567,7 @@ static bool is_empty_fast_iter (FT_HANDLE brt, FTNODE node) {
                 fill_bfe_for_full_read(&bfe, brt->ft);
                 // don't need to pass in dependent nodes as we are not
                 // modifying nodes we are pinning
-                toku_pin_ftnode_off_client_thread(
+                toku_pin_ftnode_with_dep_nodes(
                     brt->ft,
                     childblocknum,
                     fullhash,
@@ -6606,7 +6606,7 @@ bool toku_ft_is_empty_fast (FT_HANDLE brt)
         toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
         struct ftnode_fetch_extra bfe;
         fill_bfe_for_full_read(&bfe, brt->ft);
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_nodes(
             brt->ft,
             root_key,
             fullhash,

ft/ft-test-helpers.cc

@@ -254,7 +254,7 @@ toku_pin_node_with_min_bfe(FTNODE* node, BLOCKNUM b, FT_HANDLE t)
 {
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_nodes(
         t->ft, 
         b,
         toku_cachetable_hash(t->ft->cf, b),

ft/ft-verify.cc

@@ -297,7 +297,7 @@ toku_get_node_for_verify(
     uint32_t fullhash = toku_cachetable_hash(brt->ft->cf, blocknum);
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_full_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_nodes(
         brt->ft,
         blocknum,
         fullhash,

ft/tests/test-checkpoint-during-flush.cc

@@ -230,7 +230,7 @@ doit (bool after_child_pin) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -249,7 +249,7 @@ doit (bool after_child_pin) {
     assert(checkpoint_callback_called);
 
     // now let's pin the root again and make sure it is flushed
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -286,7 +286,7 @@ doit (bool after_child_pin) {
     // now pin the root, verify that we have a message in there, and that it is clean
     //
     fill_bfe_for_full_read(&bfe, c_ft->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         node_root,
         toku_cachetable_hash(c_ft->ft->cf, node_root),
@@ -307,7 +307,7 @@ doit (bool after_child_pin) {
     }
     toku_unpin_ftnode(c_ft->ft, node);
 
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         node_leaf,
         toku_cachetable_hash(c_ft->ft->cf, node_root),

ft/tests/test-checkpoint-during-merge.cc

@@ -248,7 +248,7 @@ doit (int state) {
     
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -267,7 +267,7 @@ doit (int state) {
     assert(checkpoint_callback_called);
 
     // now let's pin the root again and make sure it is has merged
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -307,7 +307,7 @@ doit (int state) {
     // now pin the root, verify that the state is what we expect
     //
     fill_bfe_for_full_read(&bfe, c_ft->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         node_root,
         toku_cachetable_hash(c_ft->ft->cf, node_root),
@@ -338,7 +338,7 @@ doit (int state) {
 
     // now let's verify the leaves are what we expect
     if (state == flt_flush_before_merge || state == flt_flush_before_pin_second_node_for_merge) {
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             left_child,
             toku_cachetable_hash(c_ft->ft->cf, left_child),
@@ -355,7 +355,7 @@ doit (int state) {
         assert(BLB_DATA(node, 0)->omt_size() == 1);
         toku_unpin_ftnode(c_ft->ft, node);
 
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             right_child,
             toku_cachetable_hash(c_ft->ft->cf, right_child),
@@ -373,7 +373,7 @@ doit (int state) {
         toku_unpin_ftnode(c_ft->ft, node);
     }
     else if (state == ft_flush_aflter_merge || state == flt_flush_before_unpin_remove) {
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             left_child,
             toku_cachetable_hash(c_ft->ft->cf, left_child),

ft/tests/test-checkpoint-during-rebalance.cc

@@ -268,7 +268,7 @@ doit (int state) {
     
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -287,7 +287,7 @@ doit (int state) {
     assert(checkpoint_callback_called);
 
     // now let's pin the root again and make sure it is has rebalanced
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -327,7 +327,7 @@ doit (int state) {
     // now pin the root, verify that the state is what we expect
     //
     fill_bfe_for_full_read(&bfe, c_ft->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         node_root,
         toku_cachetable_hash(c_ft->ft->cf, node_root),
@@ -348,7 +348,7 @@ doit (int state) {
     toku_unpin_ftnode(c_ft->ft, node);
 
     // now let's verify the leaves are what we expect
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         left_child,
         toku_cachetable_hash(c_ft->ft->cf, left_child),
@@ -364,7 +364,7 @@ doit (int state) {
     assert(BLB_DATA(node, 0)->omt_size() == 2);
     toku_unpin_ftnode(c_ft->ft, node);
     
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         right_child,
         toku_cachetable_hash(c_ft->ft->cf, right_child),

ft/tests/test-checkpoint-during-split.cc

@@ -244,7 +244,7 @@ doit (bool after_split) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -262,7 +262,7 @@ doit (bool after_split) {
     assert(checkpoint_callback_called);
 
     // now let's pin the root again and make sure it is has split
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -301,7 +301,7 @@ doit (bool after_split) {
     // now pin the root, verify that we have a message in there, and that it is clean
     //
     fill_bfe_for_full_read(&bfe, c_ft->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         c_ft->ft, 
         node_root,
         toku_cachetable_hash(c_ft->ft->cf, node_root),
@@ -329,7 +329,7 @@ doit (bool after_split) {
 
     // now let's verify the leaves are what we expect
     if (after_split) {
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             left_child,
             toku_cachetable_hash(c_ft->ft->cf, left_child),
@@ -345,7 +345,7 @@ doit (bool after_split) {
         assert(BLB_DATA(node, 0)->omt_size() == 1);
         toku_unpin_ftnode(c_ft->ft, node);
 
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             right_child,
             toku_cachetable_hash(c_ft->ft->cf, right_child),
@@ -362,7 +362,7 @@ doit (bool after_split) {
         toku_unpin_ftnode(c_ft->ft, node);
     }
     else {
-        toku_pin_ftnode_off_client_thread(
+        toku_pin_ftnode_with_dep_pairs(
             c_ft->ft, 
             left_child,
             toku_cachetable_hash(c_ft->ft->cf, left_child),

ft/tests/test-dirty-flushes-on-cleaner.cc

@@ -240,7 +240,7 @@ doit (void) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_leaf,
         toku_cachetable_hash(brt->ft->cf, node_leaf),
@@ -270,7 +270,7 @@ doit (void) {
     // on disk
     //
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_leaf,
         toku_cachetable_hash(brt->ft->cf, node_leaf),
@@ -291,7 +291,7 @@ doit (void) {
     // now let us induce a clean on the internal node
     //    
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),
@@ -316,7 +316,7 @@ doit (void) {
 
     // verify that node_internal's buffer is empty
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),

ft/tests/test-flushes-on-cleaner.cc

@@ -246,7 +246,7 @@ doit (bool keep_other_bn_in_memory) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_leaf,
         toku_cachetable_hash(brt->ft->cf, node_leaf),
@@ -293,7 +293,7 @@ doit (bool keep_other_bn_in_memory) {
         //
         fill_bfe_for_min_read(&bfe, brt->ft);
     }
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_leaf,
         toku_cachetable_hash(brt->ft->cf, node_leaf),
@@ -318,7 +318,7 @@ doit (bool keep_other_bn_in_memory) {
     // now let us induce a clean on the internal node
     //    
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),
@@ -342,7 +342,7 @@ doit (bool keep_other_bn_in_memory) {
 
     // verify that node_internal's buffer is empty
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),

ft/tests/test-hot-with-bounds.cc

@@ -183,7 +183,7 @@ doit (void) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),
@@ -213,7 +213,7 @@ doit (void) {
     // only the middle buffer, let's verify this.
     node = NULL;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_root,
         toku_cachetable_hash(t->ft->cf, node_root),

ft/tests/test-merges-on-cleaner.cc

@@ -232,7 +232,7 @@ doit (void) {
 
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),
@@ -255,7 +255,7 @@ doit (void) {
 
     // verify that node_internal's buffer is empty
     fill_bfe_for_min_read(&bfe, brt->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         brt->ft, 
         node_internal,
         toku_cachetable_hash(brt->ft->cf, node_internal),

ft/tests/test-oldest-referenced-xid-flush.cc

@@ -169,7 +169,7 @@ static void test_oldest_referenced_xid_gets_propogated(void) {
     FTNODE node = NULL;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_min_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft,
         child_nonleaf_blocknum,
         toku_cachetable_hash(t->ft->cf, child_nonleaf_blocknum),
@@ -186,7 +186,7 @@ static void test_oldest_referenced_xid_gets_propogated(void) {
     toku_unpin_ftnode(t->ft, node);
 
     // now verify the root - keep it pinned so we can flush it below
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         root_blocknum,
         toku_cachetable_hash(t->ft->cf, root_blocknum),
@@ -222,7 +222,7 @@ static void test_oldest_referenced_xid_gets_propogated(void) {
 
     // pin the child, verify that oldest referenced xid was
     // propogated from parent to child during the flush
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         child_nonleaf_blocknum,
         toku_cachetable_hash(t->ft->cf, child_nonleaf_blocknum),

ft/tests/test4244.cc

@@ -150,7 +150,7 @@ doit (void) {
     FTNODE node;
     struct ftnode_fetch_extra bfe;
     fill_bfe_for_full_read(&bfe, t->ft);
-    toku_pin_ftnode_off_client_thread(
+    toku_pin_ftnode_with_dep_pairs(
         t->ft, 
         node_internal,
         toku_cachetable_hash(t->ft->cf, node_internal),