close[t:3994] {{{svn merge -r36763:36780 ../tokudb.3994c}}}. Closes #3994.

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

newbrt/brt-internal.h

@@ -50,36 +50,6 @@ enum { BUFFER_HEADER_SIZE = (4 // height//
 			     + TREE_FANOUT * 8 // children
 			     ) };
 
-struct __attribute__((__packed__)) subtree_estimates {
-    // estimate number of rows in the tree by counting the number of rows
-    // in the leaves.  The stuff in the internal nodes is likely to be off O(1).
-    u_int64_t nkeys;  // number of distinct keys (obsolete with removal of dupsort, but not worth removing)
-    u_int64_t ndata; // number of key-data pairs (previously leafentry_estimate)
-    u_int64_t dsize;  // total size of leafentries
-    BOOL      exact;  // are the estimates exact?
-};
-
-static struct subtree_estimates const zero_estimates = {0,0,0,TRUE};
-
-static inline struct subtree_estimates __attribute__((__unused__))
-make_subtree_estimates (u_int64_t nkeys, u_int64_t ndata, u_int64_t dsize, BOOL exact) {
-    return (struct subtree_estimates){nkeys, ndata, dsize, exact};
-}
-
-static inline void
-subtract_estimates (struct subtree_estimates *a, struct subtree_estimates *b) {
-    if (a->nkeys >= b->nkeys) a->nkeys -= b->nkeys; else a->nkeys=0;
-    if (a->ndata >= b->ndata) a->ndata -= b->ndata; else a->ndata=0;
-    if (a->dsize >= b->dsize) a->dsize -= b->dsize; else a->dsize=0;
-}
-
-static inline void
-add_estimates (struct subtree_estimates *a, struct subtree_estimates *b) {
-    a->nkeys += b->nkeys;
-    a->ndata += b->ndata;
-    a->dsize += b->dsize;
-}
-
 //
 // Field in brtnode_fetch_extra that tells the 
 // partial fetch callback what piece of the node
@@ -198,8 +168,6 @@ struct   __attribute__((__packed__)) brtnode_partition {
     // for leaf nodes, they are meaningless
     BLOCKNUM     blocknum; // blocknum of child 
 
-    //estimates for a child, for leaf nodes, are estimates of basement nodes
-    struct subtree_estimates subtree_estimates; 
     //
     // at any time, the partitions may be in one of the following three states (stored in pt_state):
     //   PT_INVALID - means that the partition was just initialized
@@ -268,7 +236,6 @@ struct brtnode {
 #define BP_STATE(node,i) ((node)->bp[i].state)
 #define BP_START(node,i) ((node)->bp[i].start)
 #define BP_SIZE(node,i) ((node)->bp[i].size)
-#define BP_SUBTREE_EST(node,i) ((node)->bp[i].subtree_estimates)
 #define BP_WORKDONE(node, i)((node)->bp[i].workdone)
 
 //
@@ -780,7 +747,6 @@ brtleaf_split (struct brt_header* h, BRTNODE node, BRTNODE *nodea, BRTNODE *node
 void
 brt_leaf_apply_cmd_once (
     BASEMENTNODE bn,
-    SUBTREE_EST se,
     const BRT_MSG cmd,
     u_int32_t idx,
     LEAFENTRY le,
@@ -795,7 +761,6 @@ brt_leaf_put_cmd (
     brt_update_func update_fun,
     DESCRIPTOR desc,
     BASEMENTNODE bn, 
-    SUBTREE_EST se, 
     BRT_MSG cmd, 
     bool* made_change,
     uint64_t *workdone,

newbrt/brt-serialize.c

@@ -381,7 +381,6 @@ serialize_brtnode_info_size(BRTNODE node)
     retval += 4; // flags
     retval += 4; // height;
     retval += 4; // optimized_for_upgrade
-    retval += (3*8+1)*node->n_children; // subtree estimates for each child
     retval += node->totalchildkeylens; // total length of pivots
     retval += (node->n_children-1)*4; // encode length of each pivot
     if (node->height > 0) {
@@ -407,13 +406,6 @@ static void serialize_brtnode_info(BRTNODE node,
     wbuf_nocrc_uint(&wb, node->flags);
     wbuf_nocrc_int (&wb, node->height);    
     wbuf_nocrc_int (&wb, node->optimized_for_upgrade);    
-    // subtree estimates of each child
-    for (int i = 0; i < node->n_children; i++) {
-        wbuf_nocrc_ulonglong(&wb, BP_SUBTREE_EST(node,i).nkeys);
-        wbuf_nocrc_ulonglong(&wb, BP_SUBTREE_EST(node,i).ndata);
-        wbuf_nocrc_ulonglong(&wb, BP_SUBTREE_EST(node,i).dsize);
-        wbuf_nocrc_char     (&wb, (char)BP_SUBTREE_EST(node,i).exact);
-    }
     // pivot information
     for (int i = 0; i < node->n_children-1; i++) {
         wbuf_nocrc_bytes(&wb, kv_pair_key(node->childkeys[i]), toku_brt_pivot_key_len(node->childkeys[i]));
@@ -599,9 +591,6 @@ rebalance_brtnode_leaf(BRTNODE node, unsigned int basementnodesize)
     }
     node->max_msn_applied_to_node_on_disk = max_msn;
 
-    // now the subtree estimates
-    toku_brt_leaf_reset_calc_leaf_stats(node);
-
     toku_free(array);
     toku_free(new_pivots);
 }
@@ -1132,14 +1121,6 @@ deserialize_brtnode_info(
     // n_children is now in the header, nd the allocatio of the node->bp is in deserialize_brtnode_from_rbuf.
     assert(node->bp!=NULL); // 
 
-    for (int i=0; i < node->n_children; i++) {
-        SUBTREE_EST curr_se = &BP_SUBTREE_EST(node,i);
-        curr_se->nkeys = rbuf_ulonglong(&rb);
-        curr_se->ndata = rbuf_ulonglong(&rb);
-        curr_se->dsize = rbuf_ulonglong(&rb);
-        curr_se->exact = (BOOL) (rbuf_char(&rb) != 0);
-    }
-
     // now the pivots
     node->totalchildkeylens = 0;
     if (node->n_children > 1) {
@@ -1630,9 +1611,6 @@ toku_deserialize_bp_from_disk(BRTNODE node, int childnum, int fd, struct brtnode
     read_and_decompress_sub_block(&rb, &curr_sb);
     // at this point, sb->uncompressed_ptr stores the serialized node partition
     deserialize_brtnode_partition(&curr_sb, node, childnum, &bfe->h->descriptor, bfe->h->compare_fun);
-    if (node->height == 0) {
-        toku_brt_bn_reset_stats(node, childnum);
-    }
     toku_free(curr_sb.uncompressed_ptr);
     toku_free(raw_block);
 }
@@ -1657,9 +1635,6 @@ toku_deserialize_bp_from_compressed(BRTNODE node, int childnum,
         curr_sb->compressed_size
         );
     deserialize_brtnode_partition(curr_sb, node, childnum, desc, cmp);
-    if (node->height == 0) {
-        toku_brt_bn_reset_stats(node, childnum);
-    }
     toku_free(curr_sb->uncompressed_ptr);
     toku_free(curr_sb->compressed_ptr);
     toku_free(curr_sb);

newbrt/brt.h

@@ -296,9 +296,6 @@ BOOL toku_brt_is_empty_fast (BRT brt) __attribute__ ((warn_unused_result));
 
 BOOL toku_brt_is_recovery_logging_suppressed (BRT) __attribute__ ((warn_unused_result));
 
-void toku_brt_bn_reset_stats(BRTNODE node, int childnum);
-void toku_brt_leaf_reset_calc_leaf_stats(BRTNODE node);
-
 int toku_brt_strerror_r(int error, char *buf, size_t buflen);
 // Effect: LIke the XSI-compliant strerorr_r, extended to db_strerror().
 // If error>=0 then the result is to do strerror_r(error, buf, buflen), that is fill buf with a descriptive error message.

newbrt/brtdump.c

@@ -145,13 +145,6 @@ dump_node (int f, BLOCKNUM blocknum, struct brt_header *h) {
     printf(" n_children=%d\n", n->n_children);
     printf(" total_childkeylens=%u\n", n->totalchildkeylens);
 
-    printf(" subleafentry_estimates={");
-    for (int i=0; i<n->n_children; i++) {
-        if (i>0) printf(" ");
-        struct subtree_estimates *est = &BP_SUBTREE_EST(n,i);
-        printf("{nkey=%" PRIu64 " ndata=%" PRIu64 " dsize=%" PRIu64 " %s }", est->nkeys, est->ndata, est->dsize, est->exact ? "T" : "F");
-    }
-    printf("}\n");
     printf(" pivots:\n");
     for (int i=0; i<n->n_children-1; i++) {
         struct kv_pair *piv = n->childkeys[i];

newbrt/brtloader.c

@@ -2004,7 +2004,6 @@ int merge_files (struct merge_fileset *fs,
 
 struct subtree_info {
     int64_t block;
-    struct subtree_estimates subtree_estimates;
 };
 
 struct subtrees_info {
@@ -2024,12 +2023,11 @@ static void subtrees_info_destroy(struct subtrees_info *p) {
     p->subtrees = NULL;
 }
 
-static void allocate_node (struct subtrees_info *sts, int64_t b, const struct subtree_estimates est) {
+static void allocate_node (struct subtrees_info *sts, int64_t b) {
     if (sts->n_subtrees >= sts->n_subtrees_limit) {
 	sts->n_subtrees_limit *= 2;
 	XREALLOC_N(sts->n_subtrees_limit, sts->subtrees);
     }
-    sts->subtrees[sts->n_subtrees].subtree_estimates = est;
     sts->subtrees[sts->n_subtrees].block = b;
     sts->n_subtrees++;
 }
@@ -2363,8 +2361,7 @@ static int toku_loader_write_brt_from_q (BRTLOADER bl,
 		progress_allocation -= progress_this_node;
 		old_n_rows_remaining = n_rows_remaining;
 
-                struct subtree_estimates est = make_subtree_estimates(lbuf->nkeys, lbuf->ndata, lbuf->dsize, TRUE);
-		allocate_node(&sts, lblock, est);
+		allocate_node(&sts, lblock);
 
 		n_pivots++;
 
@@ -2406,8 +2403,7 @@ static int toku_loader_write_brt_from_q (BRTLOADER bl,
     cleanup_maxkey(&maxkey);
 
     if (lbuf) {
-        struct subtree_estimates est = make_subtree_estimates(lbuf->nkeys, lbuf->ndata, lbuf->dsize, TRUE);
-        allocate_node(&sts, lblock, est);
+        allocate_node(&sts, lblock);
         {
             int p = progress_allocation/2;
             finish_leafnode(&out, lbuf, p, bl, target_basementnodesize);
@@ -2776,7 +2772,7 @@ static void add_pair_to_leafnode (struct leaf_buf *lbuf, unsigned char *key, int
     DBT theval = { .data = val, .size = vallen };
     BRT_MSG_S cmd = { BRT_INSERT, ZERO_MSN, lbuf->xids, .u.id = { &thekey, &theval } };
     uint64_t workdone=0;
-    brt_leaf_apply_cmd_once(BLB(leafnode,0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, &workdone);
+    brt_leaf_apply_cmd_once(BLB(leafnode,0), &cmd, idx, NULL, NULL, NULL, &workdone);
 }
 
 static int write_literal(struct dbout *out, void*data,  size_t len) {
@@ -2961,13 +2957,10 @@ static int setup_nonleaf_block (int n_children,
         toku_free(pivots[n_children-1].data);
         pivots[n_children-1] = zero_dbt;
 
-        struct subtree_estimates new_subtree_estimates = zero_estimates;
-
         struct subtree_info *XMALLOC_N(n_children, subtrees_array);
         for (int i = 0; i < n_children; i++) {
             int64_t from_blocknum = first_child_offset_in_subtrees + i;
             subtrees_array[i] = subtrees->subtrees[from_blocknum];
-            add_estimates(&new_subtree_estimates, &subtrees->subtrees[from_blocknum].subtree_estimates);
         }
 
         int r = allocate_block(out, blocknum);
@@ -2975,7 +2968,7 @@ static int setup_nonleaf_block (int n_children,
             toku_free(subtrees_array);
             result = r;
         } else {
-            allocate_node(next_subtrees, *blocknum, new_subtree_estimates);
+            allocate_node(next_subtrees, *blocknum);
             
             *pivots_p = pivots;
             *subtrees_info_p = subtrees_array;
@@ -3021,7 +3014,6 @@ static void write_nonleaf_node (BRTLOADER bl, struct dbout *out, int64_t blocknu
     assert(node->bp);
     for (int i=0; i<n_children; i++) {
         BP_BLOCKNUM(node,i)  = make_blocknum(subtree_info[i].block); 
-        BP_SUBTREE_EST(node,i) = subtree_info[i].subtree_estimates;
         BP_STATE(node,i) = PT_AVAIL;
     }
 

newbrt/brttypes.h

@@ -24,7 +24,6 @@ typedef struct brtnode *BRTNODE;
 typedef struct brtnode_leaf_basement_node *BASEMENTNODE;
 typedef struct brtnode_nonleaf_childinfo *NONLEAF_CHILDINFO;
 typedef struct sub_block *SUB_BLOCK;
-typedef struct subtree_estimates *SUBTREE_EST;
 struct brt_header;
 struct wbuf;
 struct dbuf;

newbrt/tests/brt-clock-test.c

@@ -247,14 +247,6 @@ test_serialize_nonleaf(void) {
     sn.totalchildkeylens = 6;
     BP_BLOCKNUM(&sn, 0).b = 30;
     BP_BLOCKNUM(&sn, 1).b = 35;
-    BP_SUBTREE_EST(&sn,0).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).exact =  (BOOL)(random()%2 != 0);
-    BP_SUBTREE_EST(&sn,1).exact =  (BOOL)(random()%2 != 0);
     BP_STATE(&sn,0) = PT_AVAIL;
     BP_STATE(&sn,1) = PT_AVAIL;
     set_BNC(&sn, 0, toku_create_empty_nl());
@@ -352,14 +344,6 @@ test_serialize_leaf(void) {
     MALLOC_N(1, sn.childkeys);
     sn.childkeys[0] = kv_pair_malloc("b", 2, 0, 0);
     sn.totalchildkeylens = 2;
-    BP_SUBTREE_EST(&sn,0).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).exact =  (BOOL)(random()%2 != 0);
-    BP_SUBTREE_EST(&sn,1).exact =  (BOOL)(random()%2 != 0);
     BP_STATE(&sn,0) = PT_AVAIL;
     BP_STATE(&sn,1) = PT_AVAIL;
     set_BLB(&sn, 0, toku_create_empty_bn());

newbrt/tests/brt-serialize-benchmark.c

@@ -74,10 +74,6 @@ test_serialize_leaf(int valsize, int nelts, double entropy) {
     MALLOC_N(sn.n_children-1, sn.childkeys);
     sn.totalchildkeylens = 0;
     for (int i = 0; i < sn.n_children; ++i) {
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,i) = PT_AVAIL;
         set_BLB(&sn, i, toku_create_empty_bn());
     }
@@ -197,10 +193,6 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy) {
     sn.totalchildkeylens = 0;
     for (int i = 0; i < sn.n_children; ++i) {
         BP_BLOCKNUM(&sn, i).b = 30 + (i*5);
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,i) = PT_AVAIL;
         set_BNC(&sn, i, toku_create_empty_nl());
     }

newbrt/tests/brt-serialize-test.c

@@ -201,14 +201,6 @@ test_serialize_leaf_check_msn(enum brtnode_verify_type bft) {
     MALLOC_N(1, sn.childkeys);
     sn.childkeys[0] = kv_pair_malloc("b", 2, 0, 0);
     sn.totalchildkeylens = 2;
-    BP_SUBTREE_EST(&sn,0).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).exact =  (BOOL)(random()%2 != 0);
-    BP_SUBTREE_EST(&sn,1).exact =  (BOOL)(random()%2 != 0);
     BP_STATE(&sn,0) = PT_AVAIL;
     BP_STATE(&sn,1) = PT_AVAIL;
     set_BLB(&sn, 0, toku_create_empty_bn());
@@ -251,16 +243,6 @@ test_serialize_leaf_check_msn(enum brtnode_verify_type bft) {
 
     setup_dn(bft, fd, brt_h, &dn);
 
-    //
-    // test that subtree estimates get set
-    // rebalancing should make it 1 basement
-    //
-    assert(BP_SUBTREE_EST(&sn,0).nkeys == 3);
-    assert(BP_SUBTREE_EST(dn,0).nkeys == 3);
-    assert(BP_SUBTREE_EST(&sn,0).ndata == 3);
-    assert(BP_SUBTREE_EST(dn,0).ndata == 3);
-
-
     assert(dn->thisnodename.b==20);
 
     assert(dn->layout_version ==BRT_LAYOUT_VERSION);
@@ -349,10 +331,6 @@ test_serialize_leaf_with_large_pivots(enum brtnode_verify_type bft) {
     sn.totalchildkeylens = (sn.n_children-1)*sizeof(int);
     for (int i = 0; i < sn.n_children; ++i) {
         BP_STATE(&sn,i) = PT_AVAIL;
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
 	set_BLB(&sn, i, toku_create_empty_bn());
     }
     for (int i = 0; i < nrows; ++i) {
@@ -471,10 +449,6 @@ test_serialize_leaf_with_many_rows(enum brtnode_verify_type bft) {
     sn.totalchildkeylens = (sn.n_children-1)*sizeof(int);
     for (int i = 0; i < sn.n_children; ++i) {
         BP_STATE(&sn,i) = PT_AVAIL;
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
 	set_BLB(&sn, i, toku_create_empty_bn()); 
     }
     BLB_NBYTESINBUF(&sn, 0) = 0;
@@ -595,10 +569,6 @@ test_serialize_leaf_with_large_rows(enum brtnode_verify_type bft) {
     sn.totalchildkeylens = (sn.n_children-1)*8;
     for (int i = 0; i < sn.n_children; ++i) {
         BP_STATE(&sn,i) = PT_AVAIL;
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long) random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
 	set_BLB(&sn, i, toku_create_empty_bn());
     }
     BLB_NBYTESINBUF(&sn, 0) = 0;
@@ -717,10 +687,6 @@ test_serialize_leaf_with_empty_basement_nodes(enum brtnode_verify_type bft) {
     sn.totalchildkeylens = (sn.n_children-1)*2;
     for (int i = 0; i < sn.n_children; ++i) {
         BP_STATE(&sn,i) = PT_AVAIL;
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
 	set_BLB(&sn, i, toku_create_empty_bn());
         BLB_SEQINSERT(&sn, i) = 0;
     }
@@ -841,10 +807,6 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum brtnode_verify_type
     sn.totalchildkeylens = (sn.n_children-1)*2;
     for (int i = 0; i < sn.n_children; ++i) {
         BP_STATE(&sn,i) = PT_AVAIL;
-        BP_SUBTREE_EST(&sn,i).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,i).exact =  (BOOL)(random()%2 != 0);
 	set_BLB(&sn, i, toku_create_empty_bn());
     }
     BLB_NBYTESINBUF(&sn, 0) = 0*(KEY_VALUE_OVERHEAD+2+5) + toku_omt_size(BLB_BUFFER(&sn, 0));
@@ -956,14 +918,6 @@ test_serialize_leaf(enum brtnode_verify_type bft) {
     MALLOC_N(1, sn.childkeys);
     sn.childkeys[0] = kv_pair_malloc("b", 2, 0, 0);
     sn.totalchildkeylens = 2;
-    BP_SUBTREE_EST(&sn,0).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).exact =  (BOOL)(random()%2 != 0);
-    BP_SUBTREE_EST(&sn,1).exact =  (BOOL)(random()%2 != 0);
     BP_STATE(&sn,0) = PT_AVAIL;
     BP_STATE(&sn,1) = PT_AVAIL;
     set_BLB(&sn, 0, toku_create_empty_bn());
@@ -1085,14 +1039,6 @@ test_serialize_nonleaf(enum brtnode_verify_type bft) {
     sn.totalchildkeylens = 6;
     BP_BLOCKNUM(&sn, 0).b = 30;
     BP_BLOCKNUM(&sn, 1).b = 35;
-    BP_SUBTREE_EST(&sn,0).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).ndata = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).nkeys = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,1).dsize = random() + (((long long)random())<<32);
-    BP_SUBTREE_EST(&sn,0).exact =  (BOOL)(random()%2 != 0);
-    BP_SUBTREE_EST(&sn,1).exact =  (BOOL)(random()%2 != 0);
     BP_STATE(&sn,0) = PT_AVAIL;
     BP_STATE(&sn,1) = PT_AVAIL;
     set_BNC(&sn, 0, toku_create_empty_nl());

newbrt/tests/keyrange-large-subtree.c

-/* -*- mode: C; c-basic-offset: 4 -*- */
-#ident "$Id$"
-#ident "Copyright (c) 2011 Tokutek Inc.  All rights reserved."
-
-// verify that key_range64 can deal with >2G number of keys.
-// create a height 1 tree with 1 key in each subtree.
-// artificially set the key estimates in the subtrees to huge (2**31).
-
-#include "includes.h"
-#include "test.h"
-
-static BRTNODE
-make_node(BRT brt, int height) {
-    BRTNODE node = NULL;
-    int n_children = (height == 0) ? 1 : 0;
-    toku_create_new_brtnode(brt, &node, height, n_children);
-    if (n_children) BP_STATE(node,0) = PT_AVAIL;
-    return node;
-}
-
-static void
-append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) {
-    assert(leafnode->height == 0);
-
-    DBT thekey; toku_fill_dbt(&thekey, key, keylen);
-    DBT theval; toku_fill_dbt(&theval, val, vallen);
-
-    // get an index that we can use to create a new leaf entry
-    uint32_t idx = toku_omt_size(BLB_BUFFER(leafnode, 0));
-
-    // apply an insert to the leaf node
-    MSN msn = next_dummymsn();
-    BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
-
-    // dont forget to dirty the node
-    leafnode->dirty = 1;
-}
-
-static void
-populate_leaf(BRTNODE leafnode, int seq, int n, int *minkey, int *maxkey) {
-    for (int i = 0; i < n; i++) {
-        int k = htonl(seq + i);
-        int v = seq + i;
-        append_leaf(leafnode, &k, sizeof k, &v, sizeof v);
-    }
-    *minkey = htonl(seq);
-    *maxkey = htonl(seq + n - 1);
-}
-
-static BRTNODE
-make_tree(BRT brt, int height, int fanout, int nperleaf, int *seq, int *minkey, int *maxkey, uint64_t subtree_size) {
-    BRTNODE node;
-    if (height == 0) {
-        node = make_node(brt, 0);
-        populate_leaf(node, *seq, nperleaf, minkey, maxkey);
-        *seq += nperleaf;
-    } else {
-        node = make_node(brt, height);
-        int minkeys[fanout], maxkeys[fanout];
-        for (int childnum = 0; childnum < fanout; childnum++) {
-            BRTNODE child = make_tree(brt, height-1, fanout, nperleaf, seq, &minkeys[childnum], &maxkeys[childnum], subtree_size);
-            if (childnum == 0) 
-                toku_brt_nonleaf_append_child(node, child, NULL, 0);
-            else {
-                int k = minkeys[childnum]; // use the min key of the right subtree, which creates a broken tree
-                struct kv_pair *pivotkey = kv_pair_malloc(&k, sizeof k, NULL, 0);
-                toku_brt_nonleaf_append_child(node, child, pivotkey, sizeof k);
-            }
-            BP_SUBTREE_EST(node,childnum) = make_subtree_estimates(subtree_size, subtree_size, 0, FALSE);
-            toku_unpin_brtnode(brt, child);
-        }
-        *minkey = minkeys[0];
-        *maxkey = maxkeys[0];
-        for (int i = 1; i < fanout; i++) {
-            if (memcmp(minkey, &minkeys[i], sizeof minkeys[i]) > 0)
-                *minkey = minkeys[i];
-            if (memcmp(maxkey, &maxkeys[i], sizeof maxkeys[i]) < 0)
-                *maxkey = maxkeys[i];
-        }
-    }
-    return node;
-}
-
-static void 
-test_make_tree(int height, int fanout, int nperleaf, uint64_t subtree_size) {
-    int r;
-
-    // cleanup
-    char fname[]= __FILE__ ".brt";
-    r = unlink(fname);
-    assert(r == 0 || (r == -1 && errno == ENOENT));
-
-    // create a cachetable
-    CACHETABLE ct = NULL;
-    r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);
-    assert(r == 0);
-
-    // create the brt
-    TOKUTXN null_txn = NULL;
-    DB *null_db = NULL;
-    BRT brt = NULL;
-    r = toku_open_brt(fname, 1, &brt, 1024, 256, ct, null_txn, toku_builtin_compare_fun, null_db);
-    assert(r == 0);
-
-    // make a tree
-    int seq = 0, minkey, maxkey;
-    BRTNODE newroot = make_tree(brt, height, fanout, nperleaf, &seq, &minkey, &maxkey, subtree_size);
-
-    // discard the old root block
-    u_int32_t fullhash = 0;
-    CACHEKEY *rootp;
-    rootp = toku_calculate_root_offset_pointer(brt, &fullhash);
-
-    // set the new root to point to the new tree
-    *rootp = newroot->thisnodename;
-
-    // unpin the new root
-    toku_unpin_brtnode(brt, newroot);
-
-    // test the key range estimate
-    uint64_t less, equal, greater;
-    int k = htonl(0);
-    DBT key; toku_fill_dbt(&key, &k, sizeof k);
-    r = toku_brt_keyrange(brt, &key, &less, &equal, &greater); assert_zero(r);
-    assert(less == 0 && equal == 1 && greater == subtree_size);
-
-    // flush to the file system
-    r = toku_close_brt(brt, 0);     
-    assert(r == 0);
-
-    // shutdown the cachetable
-    r = toku_cachetable_close(&ct);
-    assert(r == 0);
-}
-
-static int
-usage(void) {
-    return 1;
-}
-
-int
-test_main (int argc , const char *argv[]) {
-    int height = 1;
-    int fanout = 2;
-    int nperleaf = 1;
-    for (int i = 1; i < argc; i++) {
-        const char *arg = argv[i];
-        if (strcmp(arg, "-v") == 0) {
-            verbose++;
-            continue;
-        }
-        if (strcmp(arg, "-q") == 0) {
-            verbose = 0;
-            continue;
-        }
-        if (strcmp(arg, "--height") == 0 && i+1 < argc) {
-            height = atoi(argv[++i]);
-            continue;
-        }
-        if (strcmp(arg, "--fanout") == 0 && i+1 < argc) {
-            fanout = atoi(argv[++i]);
-            continue;
-        }
-        if (strcmp(arg, "--nperleaf") == 0 && i+1 < argc) {
-            nperleaf = atoi(argv[++i]);
-            continue;
-        }
-        return usage();
-    }
-    test_make_tree(height, fanout, nperleaf, 0);
-    test_make_tree(height, fanout, nperleaf, 1ULL << 30);
-    test_make_tree(height, fanout, nperleaf, 1ULL << 31);
-    test_make_tree(height, fanout, nperleaf, 1ULL << 32);
-    
-    return 0;
-}

newbrt/tests/keyrange.c

@@ -2,6 +2,8 @@
 #ident "$Id$"
 #ident "Copyright (c) 2008 Tokutek Inc.  All rights reserved."
 
+// Test keyrange
+
 #include "includes.h"
 #include "test.h"
 
@@ -10,66 +12,159 @@
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;
 
-static void test_flat (void) {
-    char fname[]= __FILE__ ".brt";
-    u_int64_t limit=30000;
-    unlink(fname);
-    CACHETABLE ct;
-    int r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);                                assert(r==0);
-    BRT t;
+char fname[]= __FILE__ ".brt";
+CACHETABLE ct;
+BRT t;
+
+static void close_brt_and_ct (void) {
+    int r;
+    r = toku_close_brt(t, 0);          assert(r==0);
+    r = toku_cachetable_close(&ct);    assert(r==0);
+}
+
+static void open_brt_and_ct (bool unlink_old) {
+    int r;
+    if (unlink_old) unlink(fname);
+    r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);                                assert(r==0);
     r = toku_open_brt(fname, 1, &t, 1<<12, 1<<9, ct, null_txn, toku_builtin_compare_fun, null_db);   assert(r==0);
-    u_int64_t i;
-    for (i=0; i<limit; i++) {
+}
+
+static void close_and_reopen (void) {
+    close_brt_and_ct();
+    open_brt_and_ct(false);
+}
+
+static void reload (u_int64_t limit) {
+    for (u_int64_t i=0; i<limit; i++) {
 	char key[100],val[100];
 	snprintf(key, 100, "%08llu", (unsigned long long)2*i+1);
 	snprintf(val, 100, "%08llu", (unsigned long long)2*i+1);
-	DBT k,v;
-	r = toku_brt_insert(t, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v,val, 1+strlen(val)), null_txn);
-	assert(r == 0);
+	brt_lookup_and_check_nodup(t, key, val);
     }
-    // flatten it.
-    for (i=0; i<limit; i++) {
-	char key[100];
+}
+
+enum memory_state {
+    LEAVE_IN_MEMORY,       // leave the state in main memory
+    CLOSE_AND_RELOAD,      // close the brts and reload them into main memory (that will cause >1 partitio in many leaves.)
+    CLOSE_AND_REOPEN_LEAVE_ON_DISK   // close the brts, reopen them, but leave the state on disk.
+};
+
+static void maybe_reopen (enum memory_state ms, u_int64_t limit) {
+    switch (ms) {
+    case CLOSE_AND_RELOAD:
+	close_and_reopen();
+	reload(limit);
+	return;
+    case CLOSE_AND_REOPEN_LEAVE_ON_DISK:
+	close_and_reopen();
+	return;
+    case LEAVE_IN_MEMORY:
+	return;
+    }
+    assert(0);
+}
+
+static void test_keyrange (enum memory_state ms) {
+    u_int64_t limit=30000;
+    open_brt_and_ct(true);
+    for (u_int64_t i=0; i<limit; i++) {
+	char key[100],val[100];
 	snprintf(key, 100, "%08llu", (unsigned long long)2*i+1);
-	DBT k;
-	struct check_pair pair = {1+strlen(key), key, 1+strlen(key), key, 0};
-	r = toku_brt_lookup(t, toku_fill_dbt(&k, key, 1+strlen(key)), lookup_checkf, &pair);
-	assert(r==0);
-	assert(pair.call_count==1);
+	snprintf(val, 100, "%08llu", (unsigned long long)2*i+1);
+	DBT k,v;
+	int r = toku_brt_insert(t, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v,val, 1+strlen(val)), null_txn);
+	assert(r == 0);
     }
-    for (i=0; i<limit; i++) {
+    maybe_reopen(ms, limit);
+    {
+	u_int64_t prev_less = 0, prev_greater = 1LL << 60; 
+	u_int64_t count_less_adjacent = 0, count_greater_adjacent = 0; // count the number of times that the next value is 1 more (less) than the previous.
+	for (u_int64_t i=0; i<limit; i++) {
 	    char key[100];
 	    snprintf(key, 100, "%08llu", (unsigned long long)2*i+1);
 	    DBT k;
 	    u_int64_t less,equal,greater;
-	r = toku_brt_keyrange(t, toku_fill_dbt(&k, key, 1+strlen(key)), &less, &equal, &greater);
+	    int r = toku_brt_keyrange(t, toku_fill_dbt(&k, key, 1+strlen(key)), &less, &equal, &greater);
 	    assert(r == 0);
-	//printf("key %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
-	assert(less==(u_int64_t)i);
+	    //printf("Pkey %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i+1, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
+	    // It's an estimate, and it the values don't even change monotonically.
+	    // And all the leaves are in main memory so it's always present.
+	    if (ms!=CLOSE_AND_REOPEN_LEAVE_ON_DISK) {
 		assert(equal==1);
-	assert(less+equal+greater == limit);
+		// The first few items are exact for less.
+		if (i<70) {
+		    assert(less==i);
+		}
+		// The last few items are exact for greater.
+		if (limit-i<70) {
+		    assert(greater==limit-i-1);
+		}
+	    } else {
+		// If we closed it, it's not in main memory, and so the less and greater estimates are wrong, and we set equal to 0.
+		assert(equal==0);
+		if (i<10) {
+		    assert(less==0);
+		}
+		if (limit-i<10) {
+		    assert(greater==0);
+		}
+	    }
+	    // Count the number of times that prev_less is 1 less than less.
+	    if (prev_less+1 == less) {
+		count_less_adjacent++;
+	    }
+	    if (prev_greater-1 == greater) {
+		count_greater_adjacent++;
 	    }
-    for (i=0; i<1+limit; i++) {
+	    // the best we can do:  It's an estimate.  At least in the current implementation for this test (which has small rows)
+	    // the estimate grows monotonically as the leaf grows.
+	    prev_less = less;
+	    prev_greater = greater;
+	}
+	if (ms!=CLOSE_AND_REOPEN_LEAVE_ON_DISK) {
+	    // If we were doing the in-memory case then most keys are adjacent.
+	    assert(count_less_adjacent >= 0.9 * limit); // we expect at least 90% to be right.
+	    assert(count_greater_adjacent >= 0.9 * limit); // we expect at least 90% to be right.
+	}
+    }
+    maybe_reopen(ms, limit);
+    for (u_int64_t i=0; i<1+limit; i++) {
 	char key[100];
 	snprintf(key, 100, "%08llu", (unsigned long long)2*i);
 	DBT k;
 	u_int64_t less,equal,greater;
-	r = toku_brt_keyrange(t, toku_fill_dbt(&k, key, 1+strlen(key)), &less, &equal, &greater);
+	int r = toku_brt_keyrange(t, toku_fill_dbt(&k, key, 1+strlen(key)), &less, &equal, &greater);
 	assert(r == 0);
-	//printf("key %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
-	assert(less==(u_int64_t)i);
+	//printf("Akey %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
 	assert(equal==0);
-	assert(less+equal+greater == limit);
+	// The first few items are exact (looking a key that's not there)
+	if (ms!=CLOSE_AND_REOPEN_LEAVE_ON_DISK) {
+	    if (i<70) {
+		assert(less==i);
 	    }
-    r = toku_close_brt(t, 0);          assert(r==0);
-    r = toku_cachetable_close(&ct);    assert(r==0);
+	    // The last few items are exact (looking up a key that's not there)
+	    if (limit-i<70) {
+		assert(greater==limit-i);
+	    }
+	} else {
+	    if (i<10) {
+		assert(less==0);
+	    }
+	    if (limit-i<10) {
+		assert(greater==0);
+	    }
+	}
+    }
+    close_brt_and_ct();
 }
 
 int
 test_main (int argc , const char *argv[]) {
     default_parse_args(argc, argv);
 
-    test_flat();
+    test_keyrange(LEAVE_IN_MEMORY);
+    test_keyrange(CLOSE_AND_RELOAD);
+    test_keyrange(CLOSE_AND_REOPEN_LEAVE_ON_DISK);
 
     if (verbose) printf("test ok\n");
     return 0;

newbrt/tests/make-tree.c

@@ -38,7 +38,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
 
     // apply an insert to the leaf node
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode,0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     leafnode->max_msn_applied_to_node_on_disk = msn;
 

newbrt/tests/orthopush-flush.c

@@ -89,7 +89,7 @@ insert_random_message(NONLEAF_CHILDINFO bnc, BRT_MSG_S **save, bool *is_fresh_ou
 }
 
 static void
-insert_random_message_to_leaf(BRT t, BRTNODE leaf, int childnum, BASEMENTNODE blb, LEAFENTRY *save, XIDS xids, int pfx)
+insert_random_message_to_leaf(BRT t, BASEMENTNODE blb, LEAFENTRY *save, XIDS xids, int pfx)
 {
     int keylen = (random() % 16) + 16;
     int vallen = (random() % 1024) + 16;
@@ -116,14 +116,14 @@ insert_random_message_to_leaf(BRT t, BRTNODE leaf, int childnum, BASEMENTNODE bl
     int r = apply_msg_to_leafentry(result, NULL, &memsize, &disksize, save, NULL, NULL);
     assert_zero(r);
     bool made_change;
-    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb, &BP_SUBTREE_EST(leaf, childnum), result, &made_change, NULL, NULL, NULL);
+    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb, result, &made_change, NULL, NULL, NULL);
     if (msn.msn > blb->max_msn_applied.msn) {
         blb->max_msn_applied = msn;
     }
 }
 
 static void
-insert_same_message_to_leaves(BRT t, BRTNODE leaf1, BRTNODE leaf2, int childnum, BASEMENTNODE blb1, BASEMENTNODE blb2, LEAFENTRY *save, XIDS xids, int pfx)
+insert_same_message_to_leaves(BRT t, BASEMENTNODE blb1, BASEMENTNODE blb2, LEAFENTRY *save, XIDS xids, int pfx)
 {
     int keylen = (random() % 16) + 16;
     int vallen = (random() % 1024) + 16;
@@ -150,11 +150,11 @@ insert_same_message_to_leaves(BRT t, BRTNODE leaf1, BRTNODE leaf2, int childnum,
     int r = apply_msg_to_leafentry(result, NULL, &memsize, &disksize, save, NULL, NULL);
     assert_zero(r);
     bool made_change;
-    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb1, &BP_SUBTREE_EST(leaf1, childnum), result, &made_change, NULL, NULL, NULL);
+    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb1, result, &made_change, NULL, NULL, NULL);
     if (msn.msn > blb1->max_msn_applied.msn) {
         blb1->max_msn_applied = msn;
     }
-    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb2, &BP_SUBTREE_EST(leaf2, childnum), result, &made_change, NULL, NULL, NULL);
+    brt_leaf_put_cmd(t->compare_fun, t->update_fun, NULL, blb2, result, &made_change, NULL, NULL, NULL);
     if (msn.msn > blb2->max_msn_applied.msn) {
         blb2->max_msn_applied = msn;
     }
@@ -509,7 +509,7 @@ flush_to_leaf(BRT t, bool make_leaf_up_to_date, bool use_flush) {
     int total_size = 0;
     for (i = 0; total_size < 4*M; ++i) {
         total_size -= child_blbs[i%8]->n_bytes_in_buffer;
-        insert_random_message_to_leaf(t, child, i%8, child_blbs[i%8], &child_messages[i], xids_123, i%8);
+        insert_random_message_to_leaf(t, child_blbs[i%8], &child_messages[i], xids_123, i%8);
         total_size += child_blbs[i%8]->n_bytes_in_buffer;
         if (i % 8 < 7) {
             u_int32_t keylen;
@@ -730,7 +730,7 @@ flush_to_leaf_with_keyrange(BRT t, bool make_leaf_up_to_date) {
     int total_size = 0;
     for (i = 0; total_size < 4*M; ++i) {
         total_size -= child_blbs[i%8]->n_bytes_in_buffer;
-        insert_random_message_to_leaf(t, child, i%8, child_blbs[i%8], &child_messages[i], xids_123, i%8);
+        insert_random_message_to_leaf(t, child_blbs[i%8], &child_messages[i], xids_123, i%8);
         total_size += child_blbs[i%8]->n_bytes_in_buffer;
         u_int32_t keylen;
         char *key = le_key_and_len(child_messages[i], &keylen);
@@ -904,7 +904,7 @@ compare_apply_and_flush(BRT t, bool make_leaf_up_to_date) {
     int total_size = 0;
     for (i = 0; total_size < 4*M; ++i) {
         total_size -= child1_blbs[i%8]->n_bytes_in_buffer;
-        insert_same_message_to_leaves(t, child1, child2, i%8, child1_blbs[i%8], child2_blbs[i%8], &child_messages[i], xids_123, i%8);
+        insert_same_message_to_leaves(t, child1_blbs[i%8], child2_blbs[i%8], &child_messages[i], xids_123, i%8);
         total_size += child1_blbs[i%8]->n_bytes_in_buffer;
         if (i % 8 < 7) {
             u_int32_t keylen;

newbrt/tests/test3884.c

@@ -71,10 +71,6 @@ test_split_on_boundary(void)
     MALLOC_N(sn.n_children - 1, sn.childkeys);
     sn.totalchildkeylens = 0;
     for (int bn = 0; bn < sn.n_children; ++bn) {
-        BP_SUBTREE_EST(&sn,bn).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,bn) = PT_AVAIL;
         set_BLB(&sn, bn, toku_create_empty_bn());
         BLB_NBYTESINBUF(&sn,bn) = 0;
@@ -155,10 +151,6 @@ test_split_with_everything_on_the_left(void)
     LEAFENTRY big_element;
     char *big_val = NULL;
     for (int bn = 0; bn < sn.n_children; ++bn) {
-        BP_SUBTREE_EST(&sn,bn).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,bn) = PT_AVAIL;
         set_BLB(&sn, bn, toku_create_empty_bn());
         BLB_NBYTESINBUF(&sn,bn) = 0;
@@ -249,10 +241,6 @@ test_split_on_boundary_of_last_node(void)
     LEAFENTRY big_element;
     char *big_val = NULL;
     for (int bn = 0; bn < sn.n_children; ++bn) {
-        BP_SUBTREE_EST(&sn,bn).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,bn) = PT_AVAIL;
         set_BLB(&sn, bn, toku_create_empty_bn());
         BLB_NBYTESINBUF(&sn,bn) = 0;
@@ -342,10 +330,6 @@ test_split_at_begin(void)
     sn.totalchildkeylens = 0;
     long totalbytes = 0;
     for (int bn = 0; bn < sn.n_children; ++bn) {
-        BP_SUBTREE_EST(&sn,bn).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,bn) = PT_AVAIL;
         set_BLB(&sn, bn, toku_create_empty_bn());
         BLB_NBYTESINBUF(&sn,bn) = 0;
@@ -440,10 +424,6 @@ test_split_at_end(void)
     sn.totalchildkeylens = 0;
     long totalbytes = 0;
     for (int bn = 0; bn < sn.n_children; ++bn) {
-        BP_SUBTREE_EST(&sn,bn).ndata = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).nkeys = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).dsize = random() + (((long long)random())<<32);
-        BP_SUBTREE_EST(&sn,bn).exact =  (BOOL)(random()%2 != 0);
         BP_STATE(&sn,bn) = PT_AVAIL;
         set_BLB(&sn, bn, toku_create_empty_bn());
         BLB_NBYTESINBUF(&sn,bn) = 0;

newbrt/tests/verify-bad-msn.c

@@ -41,7 +41,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
 
     // apply an insert to the leaf node
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // Create bad tree (don't do following):
     // leafnode->max_msn_applied_to_node = msn;

newbrt/tests/verify-bad-pivots.c

@@ -29,7 +29,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

newbrt/tests/verify-dup-in-leaf.c

@@ -30,7 +30,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

newbrt/tests/verify-dup-pivots.c

@@ -29,7 +29,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

newbrt/tests/verify-misrouted-msgs.c

@@ -30,7 +30,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode,0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

newbrt/tests/verify-unsorted-leaf.c

@@ -30,7 +30,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

newbrt/tests/verify-unsorted-pivots.c

@@ -29,7 +29,7 @@ append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen
     // apply an insert to the leaf node
     MSN msn = next_dummymsn();
     BRT_MSG_S cmd = { BRT_INSERT, msn, xids_get_root_xids(), .u.id = { &thekey, &theval } };
-    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &BP_SUBTREE_EST(leafnode,0), &cmd, idx, NULL, NULL, NULL, NULL);
+    brt_leaf_apply_cmd_once(BLB(leafnode, 0), &cmd, idx, NULL, NULL, NULL, NULL);
 
     // dont forget to dirty the node
     leafnode->dirty = 1;

src/tests/keyrange.c

@@ -20,6 +20,7 @@ static void test (void) {
     r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
+    r = env->set_redzone(env, 0);                                                                                               CKERR(r);
     r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_pagesize(db, 4096);
@@ -57,9 +58,13 @@ static void test (void) {
 	r = db->key_range64(db, txn, dbt_init(&k, key, 1+strlen(key)), &less, &equal, &greater, &is_exact);
 	assert(r == 0);
 	//printf("key %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
+	if (i<30) {
 	    assert(less==(u_int64_t)i);
+	}
+	if (i+30 > limit) {
+	    assert(greater==limit-i-1);
+	}
 	assert(equal==1);
-	assert(less+equal+greater == limit);
     }
     for (i=0; i<1+limit; i++) {
 	char key[100];
@@ -70,9 +75,13 @@ static void test (void) {
 	r = db->key_range64(db, txn, dbt_init(&k, key, 1+strlen(key)), &less, &equal, &greater, &is_exact);
 	assert(r == 0);
 	//printf("key %llu/%llu %llu %llu %llu\n", (unsigned long long)2*i, (unsigned long long)2*limit, (unsigned long long)less, (unsigned long long)equal, (unsigned long long)greater);
-	assert(less==(u_int64_t)i);
 	assert(equal==0);
-	assert(less+equal+greater == limit);
+	if (i<30) {
+	    assert(less==(u_int64_t)i);
+	}
+	if (i+30 > limit) {
+	    assert(greater==limit-i);
+	}
     }
     r=txn->commit(txn, 0);    assert(r==0);
     r = db->close(db, 0);     assert(r==0);

src/tests/stat64.c

@@ -21,6 +21,7 @@ test_stat64 (unsigned int N) {
     DB *db;
     DB_TXN *txn;
     r = db_env_create(&env, 0);                                           CKERR(r);
+    r = env->set_redzone(env, 0);                                         CKERR(r);
 
     r = env->set_cachesize(env, 0, 20*1000000, 1);
     r = env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);