refs #4937, merge to main

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

ft/cachetable.cc

@@ -728,6 +728,13 @@ static void cachetable_partial_eviction(void* extra) {
     bjm_remove_background_job(cf->bjm);
 }
 
+void toku_cachetable_swap_pair_values(PAIR old_pair, PAIR new_pair) {
+    void* old_value = old_pair->value_data;
+    void* new_value = new_pair->value_data;
+    old_pair->value_data = new_value;
+    new_pair->value_data = old_value;
+}
+
 void toku_cachetable_maybe_flush_some(CACHETABLE ct) {
     // TODO: <CER> Maybe move this...
     ct->ev.signal_eviction_thread();

ft/cachetable.h

@@ -208,6 +208,9 @@ void *toku_cachefile_get_userdata(CACHEFILE);
 CACHETABLE toku_cachefile_get_cachetable(CACHEFILE cf);
 // Effect: Get the cachetable.
 
+void toku_cachetable_swap_pair_values(PAIR old_pair, PAIR new_pair);
+// Effect: Swaps the value_data of old_pair and new_pair. 
+// Requires: both old_pair and new_pair to be pinned with write locks.
 
 typedef enum {
     PL_READ = 0,

ft/ft-flusher-internal.h

@@ -141,6 +141,9 @@ flush_some_child(
 bool
 always_recursively_flush(FTNODE child, void* extra);
 
+bool
+never_recursively_flush(FTNODE UU(child), void* UU(extra));
+
 bool
 dont_destroy_basement_nodes(void* extra);
 

ft/ft-flusher.cc

@@ -202,6 +202,12 @@ always_recursively_flush(FTNODE UU(child), void* UU(extra))
     return true;
 }
 
+bool
+never_recursively_flush(FTNODE UU(child), void* UU(extra))
+{
+    return false;
+}
+
 static bool
 recurse_if_child_is_gorged(FTNODE child, void* UU(extra))
 {
@@ -395,8 +401,6 @@ ct_maybe_merge_child(struct flusher_advice *fa,
 
         FTNODE root_node = NULL;
         {
-            toku_ft_grab_treelock(h);
-
             uint32_t fullhash;
             CACHEKEY root;
             toku_calculate_root_offset_pointer(h, &root, &fullhash);
@@ -404,8 +408,6 @@ ct_maybe_merge_child(struct flusher_advice *fa,
             fill_bfe_for_full_read(&bfe, h);
             toku_pin_ftnode_off_client_thread(h, root, fullhash, &bfe, PL_WRITE_EXPENSIVE, 0, NULL, &root_node);
             toku_assert_entire_node_in_memory(root_node);
-
-            toku_ft_release_treelock(h);
         }
 
         (void) __sync_fetch_and_add(&STATUS_VALUE(FT_FLUSHER_CLEANER_NUM_LEAF_MERGES_STARTED), 1);
@@ -1649,6 +1651,51 @@ update_cleaner_status(
     }
 }
 
+static void
+dummy_update_status(
+    FTNODE UU(child),
+    int UU(dirtied),
+    void* UU(extra)
+    ) 
+{
+}
+
+static int
+dummy_pick_heaviest_child(FT UU(h),
+                    FTNODE UU(parent),
+                    void* UU(extra))
+{
+    assert(false);
+    return -1;
+}
+
+void toku_ft_split_child(
+    FT ft,
+    FTNODE node,
+    int childnum,
+    FTNODE child
+    )
+{
+    struct flusher_advice fa;
+    flusher_advice_init(
+        &fa,
+        dummy_pick_heaviest_child,
+        dont_destroy_basement_nodes,
+        never_recursively_flush,
+        default_merge_child,
+        dummy_update_status,
+        default_pick_child_after_split,
+        NULL
+        );
+    ft_split_child(
+        ft,
+        node,
+        childnum, // childnum to split
+        child,
+        &fa
+        );
+}
+
 int
 toku_ftnode_cleaner_callback(
     void *ftnode_pv,

ft/ft-hot-flusher.cc

@@ -266,8 +266,6 @@ toku_ft_hot_optimize(FT_HANDLE brt,
         uint32_t fullhash;
 
         {
-            toku_ft_grab_treelock(brt->ft);
-
             // Get root node (the first parent of each successive HOT
             // call.)
             toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
@@ -282,8 +280,6 @@ toku_ft_hot_optimize(FT_HANDLE brt,
                                                NULL,
                                                &root);
             toku_assert_entire_node_in_memory(root);
-
-            toku_ft_release_treelock(brt->ft);
         }
 
         // Prepare HOT diagnostics.

ft/ft-internal.h

@@ -383,7 +383,7 @@ struct ft_header {
     // last time that this tree was verified
     uint64_t time_of_last_verification;
 
-    // this field is protected by tree_lock, see comment for tree_lock
+    // this field is essentially a const
     BLOCKNUM root_blocknum;
 
     const unsigned int flags;
@@ -434,12 +434,6 @@ struct ft {
 
     // These are not read-only:
 
-    // lock used by a thread to pin the root node to start a descent into 
-    // the tree. This lock protects the blocknum of the root node (root_blocknum). Any 
-    // thread that wants to descend down the tree starting at the root 
-    // must grab this lock before pinning the root.
-    toku_mutex_t tree_lock;
-
     // protected by blocktable lock
     BLOCK_TABLE blocktable;
 
@@ -656,6 +650,14 @@ extern bool toku_ftnode_pf_req_callback(void* ftnode_pv, void* read_extraargs);
 int toku_ftnode_pf_callback(void* ftnode_pv, void* UU(disk_data), void* read_extraargs, int fd, PAIR_ATTR* sizep);
 extern int toku_ftnode_cleaner_callback( void *ftnode_pv, BLOCKNUM blocknum, uint32_t fullhash, void *extraargs);
 
+// Given pinned node and pinned child, split child into two
+// and update node with information about its new child.
+void toku_ft_split_child(
+    FT h,
+    FTNODE node,
+    int childnum,
+    FTNODE child
+    );
 static inline CACHETABLE_WRITE_CALLBACK get_write_callbacks_for_node(FT h) {
     CACHETABLE_WRITE_CALLBACK wc;
     wc.flush_callback = toku_ftnode_flush_callback;

ft/ft-ops.cc

@@ -1278,49 +1278,82 @@ toku_initialize_empty_ftnode (FTNODE n, BLOCKNUM nodename, int height, int num_c
 }
 
 static void
-ft_init_new_root(FT ft, FTNODE nodea, FTNODE nodeb, DBT splitk, CACHEKEY *rootp, FTNODE *newrootp)
-// Effect:  Create a new root node whose two children are NODEA and NODEB, and the pivotkey is SPLITK.
-//  Store the new root's identity in *ROOTP, and the node in *NEWROOTP.
-//  Unpin nodea and nodeb.
+ft_init_new_root(FT ft, FTNODE oldroot, FTNODE *newrootp)
+// Effect:  Create a new root node whose two children are the split of oldroot.
+//  oldroot is unpinned in the process.
 //  Leave the new root pinned.
 {
-    FTNODE XMALLOC(newroot);
-    int new_height = nodea->height+1;
-    BLOCKNUM newroot_diskoff;
-    toku_allocate_blocknum(ft->blocktable, &newroot_diskoff, ft);
+    FTNODE newroot;
+
+    BLOCKNUM old_blocknum = oldroot->thisnodename;
+    uint32_t old_fullhash = oldroot->fullhash;
+    PAIR old_pair = oldroot->ct_pair;
+    
+    int new_height = oldroot->height+1;
+    uint32_t new_fullhash;
+    BLOCKNUM new_blocknum;
+    PAIR new_pair = NULL;
+
+    cachetable_put_empty_node_with_dep_nodes(
+        ft,
+        1,
+        &oldroot,
+        &new_blocknum,
+        &new_fullhash,
+        &newroot
+        );
+    new_pair = newroot->ct_pair;
+    
     assert(newroot);
-    *rootp=newroot_diskoff;
     assert(new_height > 0);
-    toku_initialize_empty_ftnode (newroot, newroot_diskoff, new_height, 2, ft->h->layout_version, ft->h->nodesize, ft->h->flags);
-    //printf("new_root %lld %d %lld %lld\n", newroot_diskoff, newroot->height, nodea->thisnodename, nodeb->thisnodename);
-    //printf("%s:%d Splitkey=%p %s\n", __FILE__, __LINE__, splitkey, splitkey);
-    toku_copyref_dbt(&newroot->childkeys[0], splitk);
-    newroot->totalchildkeylens=splitk.size;
-    BP_BLOCKNUM(newroot,0)=nodea->thisnodename;
-    BP_BLOCKNUM(newroot,1)=nodeb->thisnodename;
-    {
-        MSN msna = nodea->max_msn_applied_to_node_on_disk;
-        MSN msnb = nodeb->max_msn_applied_to_node_on_disk;
-        invariant(msna.msn == msnb.msn);
-        newroot->max_msn_applied_to_node_on_disk = msna;
-    }
+    toku_initialize_empty_ftnode (
+        newroot, 
+        new_blocknum, 
+        new_height, 
+        1, 
+        ft->h->layout_version, 
+        ft->h->nodesize, 
+        ft->h->flags
+        );
+    MSN msna = oldroot->max_msn_applied_to_node_on_disk;
+    newroot->max_msn_applied_to_node_on_disk = msna;
     BP_STATE(newroot,0) = PT_AVAIL;
-    BP_STATE(newroot,1) = PT_AVAIL;
     newroot->dirty = 1;
-    //printf("%s:%d put %lld\n", __FILE__, __LINE__, newroot_diskoff);
-    uint32_t fullhash = toku_cachetable_hash(ft->cf, newroot_diskoff);
-    newroot->fullhash = fullhash;
-    toku_cachetable_put(ft->cf, newroot_diskoff, fullhash, newroot, make_ftnode_pair_attr(newroot), get_write_callbacks_for_node(ft), toku_node_save_ct_pair);
-
-    //at this point, newroot is associated with newroot_diskoff, nodea is associated with root_blocknum
-    // make newroot_diskoff point to nodea
-    // make root_blocknum point to newroot
-    // also modify the blocknum and fullhash of nodea and newroot
-    // before doing this, assert(nodea->blocknum == ft->root_blocknum)
-    
-    toku_unpin_ftnode(ft, nodea);
-    toku_unpin_ftnode(ft, nodeb);
-    *newrootp = newroot;
+
+    // now do the "switcheroo"
+    BP_BLOCKNUM(newroot,0) = new_blocknum;
+    newroot->thisnodename = old_blocknum;
+    newroot->fullhash = old_fullhash;
+    newroot->ct_pair = old_pair;
+
+    oldroot->thisnodename = new_blocknum;
+    oldroot->fullhash = new_fullhash;
+    oldroot->ct_pair = new_pair;
+
+    toku_cachetable_swap_pair_values(old_pair, new_pair);
+
+    toku_ft_split_child(
+        ft,
+        newroot,
+        0, // childnum to split
+        oldroot
+        );
+
+    // ft_split_child released locks on newroot
+    // and oldroot, so now we repin and
+    // return to caller
+    struct ftnode_fetch_extra bfe;
+    fill_bfe_for_full_read(&bfe, ft);
+    toku_pin_ftnode_off_client_thread(
+        ft,
+        old_blocknum,
+        old_fullhash,
+        &bfe,
+        PL_WRITE_EXPENSIVE, // may_modify_node
+        0,
+        NULL,
+        newrootp
+        );
 }
 
 static void
@@ -2055,35 +2088,21 @@ ft_nonleaf_put_cmd (ft_compare_func compare_fun, DESCRIPTOR desc, FTNODE node, F
 
 
 // return true if root changed, false otherwise
-static bool
-ft_process_maybe_reactive_root (FT ft, CACHEKEY *rootp, FTNODE *nodep) {
+static void
+ft_process_maybe_reactive_root (FT ft, FTNODE *nodep) {
     FTNODE node = *nodep;
     toku_assert_entire_node_in_memory(node);
     enum reactivity re = get_node_reactivity(node);
     switch (re) {
     case RE_STABLE:
-        return false;
+        return;
     case RE_FISSIBLE:
     {
-        // The root node should split, so make a new root.
-        FTNODE nodea,nodeb;
-        DBT splitk;
-        assert(ft->h->nodesize>=node->nodesize); /* otherwise we might be in trouble because the nodesize shrank. */
-        //
-        // This happens on the client thread with the ydb lock, so it is safe to
-        // not pass in dependent nodes. Although if we wanted to, we could pass
-        // in just node. That would be correct.
-        //
-        if (node->height==0) {
-            ftleaf_split(ft, node, &nodea, &nodeb, &splitk, true, 0, NULL);
-        } else {
-            ft_nonleaf_split(ft, node, &nodea, &nodeb, &splitk, 0, NULL);
-        }
-        ft_init_new_root(ft, nodea, nodeb, splitk, rootp, nodep);
-        return true;
+        ft_init_new_root(ft, node, nodep);
+        return;
     }
     case RE_FUSIBLE:
-        return false; // Cannot merge anything at the root, so return happy.
+        return; // Cannot merge anything at the root, so return happy.
     }
     abort(); // cannot happen
 }
@@ -2498,8 +2517,6 @@ toku_ft_root_put_cmd (FT ft, FT_MSG_S * cmd)
     //  others
     //
     {
-        toku_ft_grab_treelock(ft);
-
         uint32_t fullhash;
         toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
 
@@ -2529,13 +2546,7 @@ toku_ft_root_put_cmd (FT ft, FT_MSG_S * cmd)
         ft_verify_flags(ft, node);
 
         // first handle a reactive root, then put in the message
-        CACHEKEY new_root_key;
-        bool root_changed = ft_process_maybe_reactive_root(ft, &new_root_key, &node);
-        if (root_changed) {
-            toku_ft_set_new_root_blocknum(ft, new_root_key);
-        }
-
-        toku_ft_release_treelock(ft);
+        ft_process_maybe_reactive_root(ft, &node);
     }
     push_something_at_root(ft, &node, cmd);
     // verify that msn of latest message was captured in root node (push_something_at_root() did not release ydb lock)
@@ -4822,7 +4833,6 @@ try_again:
         );
     FTNODE node = NULL;
     {
-        toku_ft_grab_treelock(ft);
         uint32_t fullhash;
         CACHEKEY root_key;
         toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
@@ -4847,7 +4857,6 @@ try_again:
             // end it.
             toku_cachetable_end_batched_pin(ft->cf);
         }
-        toku_ft_release_treelock(ft);
     }
 
     uint tree_height = node->height + 1;  // How high is the tree?  This is the height of the root node plus one (leaf is at height 0).
@@ -5397,8 +5406,6 @@ try_again:
         uint64_t less = 0, equal = 0, greater = 0;
         FTNODE node = NULL;
         {
-            toku_ft_grab_treelock(brt->ft);
-
             uint32_t fullhash;
             CACHEKEY root_key;
             toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
@@ -5413,7 +5420,6 @@ try_again:
                 NULL,
                 &node
                 );
-            toku_ft_release_treelock(brt->ft);
         }
 
         struct unlock_ftnode_extra unlock_extra = {brt,node,false};
@@ -5532,14 +5538,10 @@ int toku_dump_ft (FILE *f, FT_HANDLE brt) {
     assert(brt->ft);
     toku_dump_translation_table(f, brt->ft->blocktable);
     {
-        toku_ft_grab_treelock(brt->ft);
-
         uint32_t fullhash = 0;
         CACHEKEY root_key;
         toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
         r = toku_dump_ftnode(f, brt, root_key, 0, 0, 0);
-
-        toku_ft_release_treelock(brt->ft);
     }
     return r;
 }
@@ -5705,10 +5707,7 @@ bool toku_ft_is_empty_fast (FT_HANDLE brt)
 {
     uint32_t fullhash;
     FTNODE node;
-    //assert(fullhash == toku_cachetable_hash(brt->ft->cf, *rootp));
     {
-        toku_ft_grab_treelock(brt->ft);
-
         CACHEKEY root_key;
         toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
         struct ftnode_fetch_extra bfe;
@@ -5723,8 +5722,6 @@ bool toku_ft_is_empty_fast (FT_HANDLE brt)
             NULL,
             &node
             );
-
-        toku_ft_release_treelock(brt->ft);
     }
     bool r = is_empty_fast_iter(brt, node);
     toku_unpin_ftnode(brt->ft, node);

ft/ft-serialize.cc

@@ -188,7 +188,6 @@ deserialize_ft_versioned(int fd, struct rbuf *rb, FT *ftp, uint32_t version)
     lazy_assert(translation_size_on_disk > 0);
 
     // initialize the tree lock
-    toku_ft_init_treelock(ft);
     toku_ft_init_reflock(ft);
 
     //Load translation table

ft/ft-verify.cc

@@ -459,14 +459,10 @@ toku_verify_ft_with_progress (FT_HANDLE brt, int (*progress_callback)(void *extr
     assert(brt->ft);
     FTNODE root_node = NULL;
     {
-        toku_ft_grab_treelock(brt->ft);
-
         uint32_t root_hash;
         CACHEKEY root_key;
         toku_calculate_root_offset_pointer(brt->ft, &root_key, &root_hash);
         toku_get_node_for_verify(root_key, brt, &root_node);
-
-        toku_ft_release_treelock(brt->ft);
     }
     int r = toku_verify_ftnode(brt, ZERO_MSN, ZERO_MSN, root_node, -1, NULL, NULL, progress_callback, progress_extra, 1, verbose, keep_on_going);
     if (r == 0) {

ft/ft.cc

@@ -39,7 +39,6 @@ ft_destroy(FT ft) {
     toku_blocktable_destroy(&ft->blocktable);
     if (ft->descriptor.dbt.data) toku_free(ft->descriptor.dbt.data);
     if (ft->cmp_descriptor.dbt.data) toku_free(ft->cmp_descriptor.dbt.data);
-    toku_ft_destroy_treelock(ft);
     toku_ft_destroy_reflock(ft);
     toku_free(ft->h);
 }
@@ -69,26 +68,6 @@ toku_ft_free (FT ft) {
     toku_free(ft);
 }
 
-void
-toku_ft_init_treelock(FT ft) {
-    toku_mutex_init(&ft->tree_lock, NULL);
-}
-
-void
-toku_ft_destroy_treelock(FT ft) {
-    toku_mutex_destroy(&ft->tree_lock);
-}
-
-void
-toku_ft_grab_treelock(FT ft) {
-    toku_mutex_lock(&ft->tree_lock);
-}
-
-void
-toku_ft_release_treelock(FT ft) {
-    toku_mutex_unlock(&ft->tree_lock);
-}
-
 void
 toku_ft_init_reflock(FT ft) {
     toku_mutex_init(&ft->ft_ref_lock, NULL);
@@ -475,7 +454,6 @@ toku_create_new_ft(FT *ftp, FT_OPTIONS options, CACHEFILE cf, TOKUTXN txn) {
 
     ft->h = ft_header_new(options, make_blocknum(0), (txn ? txn->ancestor_txnid64 : TXNID_NONE));
 
-    toku_ft_init_treelock(ft);
     toku_ft_init_reflock(ft);
     toku_blocktable_create_new(&ft->blocktable);
     //Assign blocknum for root block, also dirty the header

ft/ft.h

@@ -23,11 +23,6 @@ int toku_ft_unlink_on_commit(FT_HANDLE handle, TOKUTXN txn) __attribute__((__war
 //Effect: suppresses rollback logs
 void toku_ft_suppress_rollbacks(FT h, TOKUTXN txn);
 
-void toku_ft_init_treelock(FT h);
-void toku_ft_destroy_treelock(FT h);
-void toku_ft_grab_treelock(FT h);
-void toku_ft_release_treelock(FT h);
-
 void toku_ft_init_reflock(FT ft);
 void toku_ft_destroy_reflock(FT ft);
 void toku_ft_grab_reflock(FT ft);

ft/tests/ft-bfe-query.cc

@@ -339,7 +339,6 @@ test_prefetching(void) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -375,7 +374,6 @@ test_prefetching(void) {
     toku_free(sn.childkeys);
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
-    toku_ft_destroy_treelock(brt_h);
     toku_blocktable_destroy(&brt_h->blocktable);
     toku_free(brt_h->h);
     toku_free(brt_h);

ft/tests/ft-clock-test.cc

@@ -284,7 +284,6 @@ test_serialize_nonleaf(void) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -319,7 +318,6 @@ test_serialize_nonleaf(void) {
     toku_free(ndd);
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
-    toku_ft_destroy_treelock(brt_h);
     toku_blocktable_destroy(&brt_h->blocktable);
     toku_free(brt_h->h);
     toku_free(brt_h);
@@ -376,7 +374,6 @@ test_serialize_leaf(void) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -418,7 +415,6 @@ test_serialize_leaf(void) {
     toku_free(sn.childkeys);
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
-    toku_ft_destroy_treelock(brt_h);
     toku_blocktable_destroy(&brt_h->blocktable);
     toku_free(brt_h->h);
     toku_free(brt_h);

ft/tests/ft-serialize-benchmark.cc

@@ -118,7 +118,6 @@ test_serialize_leaf(int valsize, int nelts, double entropy) {
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
     brt_h->compare_fun = long_key_cmp;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -170,7 +169,6 @@ test_serialize_leaf(int valsize, int nelts, double entropy) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -252,7 +250,6 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy) {
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
     brt_h->compare_fun = long_key_cmp;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -306,7 +303,6 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);

ft/tests/ft-serialize-test.cc

@@ -262,7 +262,6 @@ test_serialize_leaf_check_msn(enum ftnode_verify_type bft, bool do_clone) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
 
@@ -345,7 +344,6 @@ test_serialize_leaf_check_msn(enum ftnode_verify_type bft, bool do_clone) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -411,7 +409,6 @@ test_serialize_leaf_with_large_pivots(enum ftnode_verify_type bft, bool do_clone
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -494,7 +491,6 @@ test_serialize_leaf_with_large_pivots(enum ftnode_verify_type bft, bool do_clone
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -556,7 +552,6 @@ test_serialize_leaf_with_many_rows(enum ftnode_verify_type bft, bool do_clone) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -637,7 +632,6 @@ test_serialize_leaf_with_many_rows(enum ftnode_verify_type bft, bool do_clone) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -706,7 +700,6 @@ test_serialize_leaf_with_large_rows(enum ftnode_verify_type bft, bool do_clone)
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -792,7 +785,6 @@ test_serialize_leaf_with_large_rows(enum ftnode_verify_type bft, bool do_clone)
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -872,7 +864,6 @@ test_serialize_leaf_with_empty_basement_nodes(enum ftnode_verify_type bft, bool
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -948,7 +939,6 @@ test_serialize_leaf_with_empty_basement_nodes(enum ftnode_verify_type bft, bool
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -1002,7 +992,6 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum ftnode_verify_type b
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -1068,7 +1057,6 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum ftnode_verify_type b
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -1137,7 +1125,6 @@ test_serialize_leaf(enum ftnode_verify_type bft, bool do_clone) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -1215,7 +1202,6 @@ test_serialize_leaf(enum ftnode_verify_type bft, bool do_clone) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);
@@ -1285,7 +1271,6 @@ test_serialize_nonleaf(enum ftnode_verify_type bft, bool do_clone) {
                  TOKU_DEFAULT_COMPRESSION_METHOD);
     brt->ft = brt_h;
     brt_h->panic = 0; brt_h->panic_string = 0;
-    toku_ft_init_treelock(brt_h);
     toku_blocktable_create_new(&brt_h->blocktable);
     { int r_truncate = ftruncate(fd, 0); CKERR(r_truncate); }
     //Want to use block #20
@@ -1342,7 +1327,6 @@ test_serialize_nonleaf(enum ftnode_verify_type bft, bool do_clone) {
 
     toku_block_free(brt_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&brt_h->blocktable);
-    toku_ft_destroy_treelock(brt_h);
     toku_free(brt_h->h);
     toku_free(brt_h);
     toku_free(brt);

src/indexer-undo-do.cc

@@ -507,12 +507,7 @@ indexer_ft_delete_committed(DB_INDEXER *indexer, DB *hotdb, DBT *hotkey, XIDS xi
     } else {
         result = toku_ydb_check_avail_fs_space(indexer->i->env);
         if (result == 0) {
-            // MO lock needed because toku_ft_root_put_cmd must be atomic
-            // with respect to checkpointing
-            // comment/question in indexer_ft_delete_provisional applies
-            toku_multi_operation_client_lock();
             result = toku_ft_send_delete(db_struct_i(hotdb)->ft_handle, hotkey, xids);
-            toku_multi_operation_client_unlock();
         }
     }
     return result;
@@ -550,12 +545,7 @@ indexer_ft_insert_committed(DB_INDEXER *indexer, DB *hotdb, DBT *hotkey, DBT *ho
     } else {
         result = toku_ydb_check_avail_fs_space(indexer->i->env);
         if (result == 0) {
-            // MO lock needed because toku_ft_root_put_cmd must be atomic
-            // with respect to checkpointing
-            // comment/question in indexer_ft_delete_provisional applies
-            toku_multi_operation_client_lock();
             result  = toku_ft_send_insert(db_struct_i(hotdb)->ft_handle, hotkey, hotval, xids, FT_INSERT);
-            toku_multi_operation_client_unlock();
         }
     }
     return result;