[t:3884] added a test that splits on the last element, exposed a bug, and fixed it

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

newbrt/brt.c

@@ -1300,22 +1300,24 @@ brtleaf_get_split_loc(
     u_int32_t size_so_far = 0;
     int i;
     for (i = 0; i < node->n_children; i++) {
-	OMT curr_buffer = BLB_BUFFER(node, i);
-	u_int32_t n_leafentries = toku_omt_size(curr_buffer);
-	u_int32_t j;
-	for (j=0; j < n_leafentries; j++) {
-	    LEAFENTRY curr_le = NULL;
-	    OMTVALUE v;
-	    int r = toku_omt_fetch(curr_buffer, j, &v);
-	    curr_le = v;
-	    assert_zero(r);
-	    size_so_far += leafentry_disksize(curr_le);
-	    if (size_so_far >= sumlesizes/2) {
-		*bn_index = i;
-		*le_index = j;
-		goto exit;
-	    }
-	}
+        OMT curr_buffer = BLB_BUFFER(node, i);
+        u_int32_t n_leafentries = toku_omt_size(curr_buffer);
+        u_int32_t j;
+        for (j=0; j < n_leafentries; j++) {
+            LEAFENTRY curr_le = NULL;
+            OMTVALUE v;
+            int r = toku_omt_fetch(curr_buffer, j, &v);
+            curr_le = v;
+            assert_zero(r);
+            size_so_far += leafentry_disksize(curr_le);
+            if (size_so_far >= sumlesizes/2 ||
+                (i == node->n_children - 1 &&
+                 j == n_leafentries - 2)) {
+                *bn_index = i;
+                *le_index = j;
+                goto exit;
+            }
+        }
     }
 exit:
     return;

newbrt/tests/test3884.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
-#ident "$Id: test3856.c 33984 2011-08-17 03:03:54Z leifwalsh $"
+#ident "$Id$"
 #ident "Copyright (c) 2007-2011 Tokutek Inc.  All rights reserved."
 
 // it used to be the case that we copied the left and right keys of a
@@ -41,10 +41,9 @@ le_fastmalloc(char *key, int keylen, char *val, int vallen)
     return r;
 }
 
-int
-test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
-    toku_memory_check = 1;
-
+static void
+test_split_on_boundary(void)
+{
     const int nodesize = 1024, eltsize = 64, bnsize = 256;
     const int keylen = sizeof(long), vallen = eltsize - keylen - (sizeof(((LEAFENTRY)NULL)->type)  // overhead from LE_CLEAN_MEMSIZE
                                                                   +sizeof(((LEAFENTRY)NULL)->keylen)
@@ -122,6 +121,104 @@ test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute_
     }
     toku_free(sn.bp);
     toku_free(sn.childkeys);
+}
+
+static void
+test_split_at_end(void)
+{
+    const int nodesize = 1024, eltsize = 64, bnsize = 256;
+    const int keylen = sizeof(long), vallen = eltsize - keylen - (sizeof(((LEAFENTRY)NULL)->type)  // overhead from LE_CLEAN_MEMSIZE
+                                                                  +sizeof(((LEAFENTRY)NULL)->keylen)
+                                                                  +sizeof(((LEAFENTRY)NULL)->u.clean.vallen));
+    const int eltsperbn = bnsize / eltsize;
+    struct brtnode sn;
+
+    int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
+
+    int r;
+
+    sn.max_msn_applied_to_node_on_disk.msn = 0;
+    sn.nodesize = nodesize;
+    sn.flags = 0x11223344;
+    sn.thisnodename.b = 20;
+    sn.layout_version = BRT_LAYOUT_VERSION;
+    sn.layout_version_original = BRT_LAYOUT_VERSION;
+    sn.height = 0;
+    const int nelts = 2 * nodesize / eltsize;
+    sn.n_children = nelts * eltsize / bnsize;
+    sn.dirty = 1;
+    LEAFENTRY elts[nelts];
+    MALLOC_N(sn.n_children, sn.bp);
+    MALLOC_N(sn.n_children - 1, sn.childkeys);
+    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;
+        BLB_OPTIMIZEDFORUPGRADE(&sn, bn) = BRT_LAYOUT_VERSION;
+        long k;
+        for (int i = 0; i < eltsperbn; ++i) {
+            k = bn * eltsperbn + i;
+            if (bn < sn.n_children - 1 || i < eltsperbn - 1) {
+                char val[vallen];
+                memset(val, k, sizeof val);
+                elts[k] = le_fastmalloc((char *) &k, keylen, val, vallen);
+            } else {  // the last element
+                char val[totalbytes + 3];  // just to be sure
+                memset(val, k, sizeof val);
+                elts[k] = le_fastmalloc((char *) &k, keylen, val, totalbytes + 3);
+            }
+            r = toku_omt_insert(BLB_BUFFER(&sn, bn), elts[k], omt_long_cmp, elts[k], NULL); assert(r == 0);
+            BLB_NBYTESINBUF(&sn, bn) += OMT_ITEM_OVERHEAD + leafentry_disksize(elts[k]);
+            totalbytes += OMT_ITEM_OVERHEAD + leafentry_disksize(elts[k]);
+        }
+        if (bn < sn.n_children - 1) {
+            sn.childkeys[bn] = kv_pair_malloc(&k, sizeof k, 0, 0);
+            sn.totalchildkeylens += (sizeof k);
+        }
+    }
+
+    unlink(fname);
+    CACHETABLE ct;
+    BRT brt;
+    r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER);   assert(r==0);
+    r = toku_open_brt(fname, 1, &brt, nodesize, bnsize, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0);
+
+    BRTNODE nodea, nodeb;
+    DBT splitk;
+    // if we haven't done it right, we should hit the assert in the top of move_leafentries
+    brtleaf_split(brt, &sn, &nodea, &nodeb, &splitk, TRUE);
+
+    toku_unpin_brtnode(brt, nodeb);
+    r = toku_close_brt(brt, NULL); assert(r == 0);
+    r = toku_cachetable_close(&ct); assert(r == 0);
+
+    if (splitk.data) {
+        toku_free(splitk.data);
+    }
+
+    for (int i = 0; i < sn.n_children - 1; ++i) {
+        kv_pair_free(sn.childkeys[i]);
+    }
+    for (int i = 0; i < sn.n_children; ++i) {
+        toku_omt_free_items(BLB_BUFFER(&sn, i));
+        destroy_basement_node(BLB(&sn, i));
+    }
+    toku_free(sn.bp);
+    toku_free(sn.childkeys);
+}
+
+int
+test_main (int argc __attribute__((__unused__)), const char *argv[] __attribute__((__unused__))) {
+    toku_memory_check = 1;
+
+    test_split_on_boundary();
+    test_split_at_end();
 
     return 0;
 }