#3099 Merge 3099 onto the main line.

{{{
svn merge -r28775:29048 https://svn.tokutek.com/tokudb/toku/tokudb.3099
}}}


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

buildheader/make_db_h.c

@@ -75,7 +75,6 @@ enum {
         TOKUDB_UPGRADE_FAILURE         = -100011,
 	TOKUDB_TRY_AGAIN               = -100012,
 	TOKUDB_NEEDS_REPAIR            = -100013,
-	TOKUDB_FINGERPRINT_ERROR       = -100014,
 };
 
 static void print_defines (void) {
@@ -227,7 +226,6 @@ static void print_defines (void) {
     dodefine(TOKUDB_UPGRADE_FAILURE);
     dodefine(TOKUDB_TRY_AGAIN);
     dodefine(TOKUDB_NEEDS_REPAIR);
-    dodefine(TOKUDB_FINGERPRINT_ERROR);
 
     /* LOADER flags */
     printf("/* LOADER flags */\n");

newbrt/Makefile

@@ -55,7 +55,6 @@ BRT_SOURCES = \
   checkpoint \
   dbufio \
   fifo \
-  fingerprint \
   key \
   leafentry \
   leaflock \

newbrt/brt-internal.h

@@ -82,7 +82,6 @@ add_estimates (struct subtree_estimates *a, struct subtree_estimates *b) {
 
 
 struct brtnode_nonleaf_childinfo {
-    u_int32_t    subtree_fingerprint;
     struct subtree_estimates subtree_estimates;
     BLOCKNUM     blocknum;
     BOOL         have_fullhash;     // do we have the full hash?
@@ -102,20 +101,16 @@ struct brtnode {
     int    layout_version_read_from_disk;  // transient, not serialized to disk, (useful for debugging)
     uint32_t build_id;       // build_id (svn rev number) of software that wrote this node to disk
     int    height; /* height is always >= 0.  0 for leaf, >0 for nonleaf. */
-    u_int32_t rand4fingerprint;
-    u_int32_t local_fingerprint; /* For leaves this is everything in the buffer.  For nonleaves, this is everything in the buffers, but does not include child subtree fingerprints. */
     int    dirty;
     u_int32_t fullhash;
     union node {
 	struct nonleaf {
-	    // Don't actually store the subree fingerprint in the in-memory data structure.
 	    int             n_children;  /* if n_children==TREE_FANOUT+1 then the tree needs to be rebalanced. */
 	    unsigned int    totalchildkeylens;
 	    unsigned int    n_bytes_in_buffers;
 
 	    struct brtnode_nonleaf_childinfo *childinfos; /* One extra so we can grow */
 
-#define BNC_SUBTREE_FINGERPRINT(node,i) ((node)->u.n.childinfos[i].subtree_fingerprint)
 #define BNC_SUBTREE_ESTIMATES(node,i) ((node)->u.n.childinfos[i].subtree_estimates)
 #define BNC_BLOCKNUM(node,i) ((node)->u.n.childinfos[i].blocknum)
 #define BNC_BUFFER(node,i) ((node)->u.n.childinfos[i].buffer)
@@ -259,7 +254,7 @@ int toku_deserialize_brtnode_from (int fd, BLOCKNUM off, u_int32_t /*fullhash*/,
 unsigned int toku_serialize_brtnode_size(BRTNODE node); /* How much space will it take? */
 int toku_keycompare (bytevec key1, ITEMLEN key1len, bytevec key2, ITEMLEN key2len);
 
-void toku_verify_or_set_counts(BRTNODE, BOOL);
+void toku_verify_or_set_counts(BRTNODE);
 
 int toku_serialize_brt_header_size (struct brt_header *h);
 int toku_serialize_brt_header_to (int fd, struct brt_header *h);
@@ -296,11 +291,6 @@ extern CACHEKEY* toku_calculate_root_offset_pointer (BRT brt, u_int32_t *root_ha
 
 static const BRTNODE null_brtnode=0;
 
-//extern u_int32_t toku_calccrc32_kvpair (const void *key, int keylen, const void *val, int vallen);
-//extern u_int32_t toku_calccrc32_kvpair_struct (const struct kv_pair *kvp);
-extern u_int32_t toku_calc_fingerprint_cmd (u_int32_t type, XIDS xids, const void *key, u_int32_t keylen, const void *val, u_int32_t vallen);
-extern u_int32_t toku_calc_fingerprint_cmdstruct (BRT_MSG cmd);
-
 // How long is the pivot key?
 unsigned int toku_brt_pivot_key_len (struct kv_pair *);
 
@@ -345,11 +335,11 @@ unsigned int toku_brtnode_which_child (BRTNODE node , DBT *k, BRT t);
 
 /* Stuff for testing */
 int toku_testsetup_leaf(BRT brt, BLOCKNUM *);
-int toku_testsetup_nonleaf (BRT brt, int height, BLOCKNUM *diskoff, int n_children, BLOCKNUM *children, u_int32_t *subtree_fingerprints, char **keys, int *keylens);
+int toku_testsetup_nonleaf (BRT brt, int height, BLOCKNUM *diskoff, int n_children, BLOCKNUM *children, char **keys, int *keylens);
 int toku_testsetup_root(BRT brt, BLOCKNUM);
 int toku_testsetup_get_sersize(BRT brt, BLOCKNUM); // Return the size on disk.
-int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM, char *key, int keylen, char *val, int vallen, u_int32_t *leaf_fingerprint);
-int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM, enum brt_msg_type, char *key, int keylen, char *val, int vallen, u_int32_t *subtree_fingerprint);
+int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM, char *key, int keylen, char *val, int vallen);
+int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM, enum brt_msg_type, char *key, int keylen, char *val, int vallen);
 
 // These two go together to do lookups in a brtnode using the keys in a command.
 struct cmd_leafval_heaviside_extra {

newbrt/brt-test-helpers.c

@@ -19,7 +19,7 @@ int toku_testsetup_leaf(BRT brt, BLOCKNUM *blocknum) {
 }
 
 // Don't bother to clean up carefully if something goes wrong.  (E.g., it's OK to have malloced stuff that hasn't been freed.)
-int toku_testsetup_nonleaf (BRT brt, int height, BLOCKNUM *blocknum, int n_children, BLOCKNUM *children, u_int32_t *subtree_fingerprints, char **keys, int *keylens) {
+int toku_testsetup_nonleaf (BRT brt, int height, BLOCKNUM *blocknum, int n_children, BLOCKNUM *children, char **keys, int *keylens) {
     BRTNODE node;
     assert(n_children<=BRT_FANOUT);
     int r = toku_read_brt_header_and_store_in_cachefile(brt->cf, MAX_LSN, &brt->h, &ignore_if_was_already_open);
@@ -32,8 +32,7 @@ int toku_testsetup_nonleaf (BRT brt, int height, BLOCKNUM *blocknum, int n_child
     node->u.n.n_bytes_in_buffers=0;
     int i;
     for (i=0; i<n_children; i++) {
-	node->u.n.childinfos[i] = (struct brtnode_nonleaf_childinfo){ .subtree_fingerprint = subtree_fingerprints[i],
-								      .subtree_estimates   = zero_estimates,
+	node->u.n.childinfos[i] = (struct brtnode_nonleaf_childinfo){ .subtree_estimates   = zero_estimates,
 								      .blocknum            = children[i],
 								      .n_bytes_in_buffer   = 0 };
 	r = toku_fifo_create(&BNC_BUFFER(node,i)); if (r!=0) return r;
@@ -66,14 +65,14 @@ int toku_testsetup_get_sersize(BRT brt, BLOCKNUM diskoff) // Return the size on
     return size;
 }
 
-int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM blocknum, char *key, int keylen, char *val, int vallen, u_int32_t *subtree_fingerprint) {
+int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM blocknum, char *key, int keylen, char *val, int vallen) {
     void *node_v;
     int r;
     r = toku_cachetable_get_and_pin(brt->cf, blocknum, toku_cachetable_hash(brt->cf, blocknum), &node_v, NULL,
 				    toku_brtnode_flush_callback, toku_brtnode_fetch_callback, brt);
     if (r!=0) return r;
     BRTNODE node=node_v;
-    toku_verify_or_set_counts(node, FALSE);
+    toku_verify_or_set_counts(node);
     assert(node->height==0);
 
     size_t lesize, disksize;
@@ -99,7 +98,6 @@ int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM blocknum, char *key, int ke
 	LEAFENTRY storeddata=storeddatav;
 	// It's already there.  So now we have to remove it and put the new one back in.
 	node->u.l.n_bytes_in_buffer -= OMT_ITEM_OVERHEAD + leafentry_disksize(storeddata);
-	node->local_fingerprint     -= node->rand4fingerprint*toku_le_crc(storeddata);
 	toku_mempool_mfree(&node->u.l.buffer_mempool, storeddata, leafentry_memsize(storeddata));
 	// Now put the new kv in.
 	toku_omt_set_at(node->u.l.buffer, leafentry, idx);
@@ -109,18 +107,16 @@ int toku_testsetup_insert_to_leaf (BRT brt, BLOCKNUM blocknum, char *key, int ke
     }
 
     node->u.l.n_bytes_in_buffer += OMT_ITEM_OVERHEAD + disksize;
-    node->local_fingerprint += node->rand4fingerprint*toku_le_crc(leafentry);
 
     node->dirty=1;
-    *subtree_fingerprint = node->local_fingerprint;
 
-    toku_verify_or_set_counts(node, FALSE);
+    toku_verify_or_set_counts(node);
 
     r = toku_unpin_brtnode(brt, node_v);
     return r;
 }
 
-int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM blocknum, enum brt_msg_type cmdtype, char *key, int keylen, char *val, int vallen, u_int32_t *subtree_fingerprint) {
+int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM blocknum, enum brt_msg_type cmdtype, char *key, int keylen, char *val, int vallen) {
     void *node_v;
     int r;
     r = toku_cachetable_get_and_pin(brt->cf, blocknum, toku_cachetable_hash(brt->cf, blocknum), &node_v, NULL,
@@ -137,9 +133,6 @@ int toku_testsetup_insert_to_nonleaf (BRT brt, BLOCKNUM blocknum, enum brt_msg_t
     XIDS xids_0 = xids_get_root_xids();
     r = toku_fifo_enq(BNC_BUFFER(node, childnum), key, keylen, val, vallen, cmdtype, xids_0);
     assert(r==0);
-    u_int32_t fdelta = node->rand4fingerprint * toku_calc_fingerprint_cmd(cmdtype, xids_0, key, keylen, val, vallen);
-    node->local_fingerprint += fdelta;
-    *subtree_fingerprint += fdelta;
     int sizediff = keylen + vallen + KEY_VALUE_OVERHEAD + BRT_CMD_OVERHEAD + xids_get_serialize_size(xids_0);
     node->u.n.n_bytes_in_buffers += sizediff;
     BNC_NBYTESINBUF(node, childnum) += sizediff;

newbrt/brt-verify.c

@@ -5,8 +5,6 @@
 
 /* Verify a BRT. */
 /* Check:
- *   The fingerprint of every node (local check)
- *   The child's fingerprint matches the parent's copy (probably don't actually do thi syet)
  *   The tree is of uniform depth (and the height is correct at every node)
  *   For each pivot key:  the max of the stuff to the left is <= the pivot key < the min of the stuff to the right.
  *   For each leaf node:  All the keys are in strictly increasing order.
@@ -15,31 +13,6 @@
 
 #include "includes.h"
 
-static int verify_local_fingerprint (BRTNODE node, int verbose) __attribute__ ((warn_unused_result));
-
-static int 
-verify_local_fingerprint (BRTNODE node, int verbose) {
-    u_int32_t fp=0;
-    int i;
-    int r = 0;
-    if (node->height>0) {
-	for (i=0; i<node->u.n.n_children; i++)
-	    FIFO_ITERATE(BNC_BUFFER(node,i), key, keylen, data, datalen, type, xid,
-			      {
-				  fp += node->rand4fingerprint * toku_calc_fingerprint_cmd(type, xid, key, keylen, data, datalen);
-			      });
-	if (fp!=node->local_fingerprint) {
-	    if (verbose) {
-		fprintf(stderr, "%s:%d local fingerprints don't match\n", __FILE__, __LINE__);
-	    }
-	    r = TOKUDB_FINGERPRINT_ERROR;
-	}
-    } else {
-	toku_verify_or_set_counts(node, FALSE);
-    }
-    return r;
-}
-
 static int 
 compare_pairs (BRT brt, struct kv_pair *a, struct kv_pair *b) {
     DBT x,y;
@@ -143,13 +116,6 @@ toku_verify_brtnode (BRT brt, BLOCKNUM blocknum, int height,
     assert(node->fullhash == fullhash);   // this is a bad failure if wrong
     if (height >= 0) 
         invariant(height == node->height);   // this is a bad failure if wrong
-    {
-	int r = verify_local_fingerprint(node, verbose);
-	if (r) {
-	    result = r;
-	    if (!keep_going_on_failure) goto done;
-	}
-    }
     if (node->height > 0) {
 	// Verify that all the pivot keys are in order.
 	for (int i = 0; i < node->u.n.n_children-2; i++) {

newbrt/brt_layout_version.h

@@ -17,10 +17,12 @@ enum brt_layout_version_e {
     BRT_LAYOUT_VERSION_11 = 11, // Diff from 10 to 11: Nested transaction leafentries (completely redesigned).  BRT_CMDs on disk now support XIDS (multiple txnids) instead of exactly one.
     BRT_LAYOUT_VERSION_12 = 12, // Diff from 11 to 12: Added BRT_CMD 'BRT_INSERT_NO_OVERWRITE', compressed block format, num old blocks
     BRT_LAYOUT_VERSION_13 = 13, // Diff from 12 to 13: Fixed loader pivot bug, added build_id to every node, timestamps to brtheader 
-    BRT_LAYOUT_VERSION_14 = 14, // Diff from 13 to 14: Added MVCC, deprecated TOKU_DB_VALCMP_BUILTIN(_13)
+    BRT_LAYOUT_VERSION_14 = 14, // Diff from 13 to 14: Added MVCC, deprecated TOKU_DB_VALCMP_BUILTIN(_13), Remove fingerprints
     BRT_NEXT_VERSION,           // the version after the current version
     BRT_LAYOUT_VERSION   = BRT_NEXT_VERSION-1, // A hack so I don't have to change this line.
     BRT_LAYOUT_MIN_SUPPORTED_VERSION = BRT_LAYOUT_VERSION_13 // Minimum version supported
 };
 
+// Define this symbolically so the knowledge of exactly which layout version got rid of fingerprints isn't spread all over the code.
+#define BRT_LAST_LAYOUT_VERSION_WITH_FINGERPRINT BRT_LAYOUT_VERSION_13
 #endif

newbrt/brtdump.c

@@ -149,19 +149,11 @@ dump_node (int f, BLOCKNUM blocknum, struct brt_header *h) {
     printf(" layout_version_original=%d\n", n->layout_version_original);
     printf(" layout_version_read_from_disk=%d\n", n->layout_version_read_from_disk);
     printf(" build_id=%d\n", n->build_id);
-    printf(" rand4fp     =%08x\n", n->rand4fingerprint);
-    printf(" localfp     =%08x\n", n->local_fingerprint);
     if (n->height>0) {
 	printf(" n_children=%d\n", n->u.n.n_children);
 	printf(" total_childkeylens=%u\n", n->u.n.totalchildkeylens);
 	printf(" n_bytes_in_buffers=%u\n", n->u.n.n_bytes_in_buffers);
 	int i;
-	printf(" subfingerprints={");
-	for (i=0; i<n->u.n.n_children; i++) {
-	    if (i>0) printf(" ");
-	    printf("%08x", BNC_SUBTREE_FINGERPRINT(n, i));
-	}
-	printf("}\n");
 	printf(" subleafentry_estimates={");
 	for (i=0; i<n->u.n.n_children; i++) {
 	    if (i>0) printf(" ");

newbrt/brtloader.c

@@ -1988,7 +1988,6 @@ int merge_files (struct merge_fileset *fs,
 struct subtree_info {
     int64_t block;
     struct subtree_estimates subtree_estimates;
-    int32_t fingerprint;
 };
 
 struct subtrees_info {
@@ -2008,14 +2007,13 @@ 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, const int fingerprint) {
+static void allocate_node (struct subtrees_info *sts, int64_t b, const struct subtree_estimates est) {
     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->subtrees[sts->n_subtrees].fingerprint = fingerprint;
     sts->n_subtrees++;
 }
 
@@ -2029,9 +2027,6 @@ struct dbuf {
 struct leaf_buf {
     int64_t blocknum;
     struct dbuf dbuf;
-    unsigned int rand4fingerprint;
-    unsigned int local_fingerprint;
-    int local_fingerprint_p;
     int nkeys, ndata, dsize, n_in_buf;
     int nkeys_p, ndata_p, dsize_p, partitions_p, n_in_buf_p;
     TXNID xid;
@@ -2231,14 +2226,10 @@ static struct leaf_buf *start_leaf (struct dbout *out, const DESCRIPTOR UU(desc)
     putbuf_int32(&lbuf->dbuf, target_nodesize);
     putbuf_int32(&lbuf->dbuf, flags);
     putbuf_int32(&lbuf->dbuf, height);
-    lbuf->rand4fingerprint = loader_random();
-    putbuf_int32(&lbuf->dbuf, lbuf->rand4fingerprint);
-    lbuf->local_fingerprint = 0;
     lbuf->nkeys = lbuf->ndata = lbuf->dsize = 0;
     lbuf->n_in_buf = 0;
     
     // leave these uninitialized for now.
-    lbuf->local_fingerprint_p = lbuf->dbuf.off;    lbuf->dbuf.off+=4;
     lbuf->nkeys_p             = lbuf->dbuf.off;    lbuf->dbuf.off+=8;
     lbuf->ndata_p             = lbuf->dbuf.off;    lbuf->dbuf.off+=8;
     lbuf->dsize_p             = lbuf->dbuf.off;    lbuf->dbuf.off+=8;
@@ -2415,7 +2406,7 @@ static int toku_loader_write_brt_from_q (BRTLOADER bl,
 		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, lbuf->local_fingerprint);
+		allocate_node(&sts, lblock, est);
 
 		n_pivots++;
 
@@ -2458,7 +2449,7 @@ static int toku_loader_write_brt_from_q (BRTLOADER bl,
 
     if (lbuf) {
         struct subtree_estimates est = make_subtree_estimates(lbuf->nkeys, lbuf->ndata, lbuf->dsize, TRUE);
-        allocate_node(&sts, lblock, est, lbuf->local_fingerprint);
+        allocate_node(&sts, lblock, est);
         {
             int p = progress_allocation/2;
             finish_leafnode(&out, lbuf, p, bl);
@@ -2826,13 +2817,8 @@ static void add_pair_to_leafnode (struct leaf_buf *lbuf, unsigned char *key, int
     if (!lbuf->dbuf.error) {
         invariant(le_off + le_len == lbuf->dbuf.off);
         u_int32_t this_x = x1764_memory(lbuf->dbuf.buf + le_off, le_len);
-        u_int32_t this_prod = lbuf->rand4fingerprint * this_x;
-        lbuf->local_fingerprint += this_prod;
         if (0) {
             printf("%s:%d x1764(buf+%d, %d)=%8x\n", __FILE__, __LINE__, le_off, le_len, this_x);
-            printf("%s:%d rand4fingerprint=%8x\n", __FILE__, __LINE__, lbuf->rand4fingerprint);
-            printf("%s:%d this_prod=%8x\n", __FILE__, __LINE__, this_prod);
-            printf("%s:%d local_fingerprint=%8x\n", __FILE__, __LINE__, lbuf->local_fingerprint);
         }
     }
 }
@@ -2850,8 +2836,6 @@ static void finish_leafnode (struct dbout *out, struct leaf_buf *lbuf, int progr
     int result = 0;
 
     //printf("  finishing leaf node progress=%d fin at %d\n", bl->progress, bl->progress+progress_allocation);
-    //printf("local_fingerprint=%8x\n", lbuf->local_fingerprint);
-    putbuf_int32_at(&lbuf->dbuf, lbuf->local_fingerprint_p, lbuf->local_fingerprint);
     putbuf_int64_at(&lbuf->dbuf, lbuf->nkeys_p,             lbuf->nkeys);
     putbuf_int64_at(&lbuf->dbuf, lbuf->ndata_p,             lbuf->ndata);
     putbuf_int64_at(&lbuf->dbuf, lbuf->dsize_p,             lbuf->dsize);
@@ -3098,12 +3082,10 @@ static int setup_nonleaf_block (int n_children,
         struct subtree_estimates new_subtree_estimates = zero_estimates;
 
         struct subtree_info *XMALLOC_N(n_children, subtrees_array);
-        int32_t fingerprint = 0;
         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);
-            fingerprint += subtrees->subtrees[from_blocknum].fingerprint;
         }
 
         int r = allocate_block(out, blocknum);
@@ -3111,7 +3093,7 @@ static int setup_nonleaf_block (int n_children,
             toku_free(subtrees_array);
             result = r;
         } else {
-            allocate_node(next_subtrees, *blocknum, new_subtree_estimates, fingerprint);
+            allocate_node(next_subtrees, *blocknum, new_subtree_estimates);
             
             *pivots_p = pivots;
             *subtrees_info_p = subtrees_array;
@@ -3147,8 +3129,6 @@ static void write_nonleaf_node (BRTLOADER bl, struct dbout *out, int64_t blocknu
     node->height=height;
     node->u.n.n_children = n_children;
     node->flags = 0;
-    node->local_fingerprint = 0;
-    node->rand4fingerprint = loader_random();
 
     XMALLOC_N(n_children-1, node->u.n.childkeys);
     for (int i=0; i<n_children-1; i++) 
@@ -3168,7 +3148,6 @@ static void write_nonleaf_node (BRTLOADER bl, struct dbout *out, int64_t blocknu
     XMALLOC_N(n_children, node->u.n.childinfos);
     for (int i=0; i<n_children; i++) {
 	struct brtnode_nonleaf_childinfo *ci = &node->u.n.childinfos[i];
-	ci->subtree_fingerprint = subtree_info[i].fingerprint;
 	ci->subtree_estimates   = subtree_info[i].subtree_estimates;
 	ci->blocknum            = make_blocknum(subtree_info[i].block);
 	ci->have_fullhash       = FALSE;

newbrt/fingerprint.c

-/* -*- mode: C; c-basic-offset: 4 -*- */
-#ident "$Id$"
-#ident "Copyright (c) 2007-2010 Tokutek Inc.  All rights reserved."
-#ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
-
-
-#include "includes.h"
-
-// Calculate the fingerprint for a kvpair
-static void toku_calc_more_murmur_kvpair (struct x1764 *mm, const void *key, int keylen, const void *val, int vallen) {
-    int i;
-    i = toku_htod32(keylen);
-    x1764_add(mm,  (void*)&i, 4);
-    x1764_add(mm,  key, keylen);
-    i = toku_htod32(vallen);
-    x1764_add(mm, (void*)&i, 4);
-    x1764_add(mm, val, vallen);
-}
-
-#if 0
- u_int32_t toku_calccrc32_kvpair (const void *key, int keylen, const void *val, int vallen) {
-    return toku_calc_more_crc32_kvpair(toku_null_crc, key, keylen, val, vallen);
-}
-#endif
-
-u_int32_t toku_calc_fingerprint_cmd (u_int32_t type, XIDS xids, const void *key, u_int32_t keylen, const void *val, u_int32_t vallen) {
-    unsigned char type_c = (unsigned char)type;
-    struct x1764 mm;
-    x1764_init(&mm);
-    x1764_add(&mm, &type_c, 1);
-    toku_calc_more_murmur_xids(&mm, xids);
-    toku_calc_more_murmur_kvpair(&mm, key, keylen, val, vallen);
-    return x1764_finish(&mm);
-}

newbrt/leafentry.c

@@ -4,11 +4,6 @@
 
 #include "includes.h"
 
-u_int32_t toku_le_crc(LEAFENTRY v) {
-    return x1764_memory(v, leafentry_memsize(v));
-}
-
-
 void wbuf_LEAFENTRY(struct wbuf *w, LEAFENTRY le) {
     wbuf_literal_bytes(w, le, leafentry_disksize(le));
 }

newbrt/leafentry.h

@@ -116,8 +116,6 @@ struct __attribute__ ((__packed__)) leafentry {
 typedef struct leafentry *LEAFENTRY;
 typedef struct leafentry_13 *LEAFENTRY_13;
 
-u_int32_t toku_le_crc(LEAFENTRY v);
-
 size_t leafentry_memsize (LEAFENTRY le); // the size of a leafentry in memory.
 size_t leafentry_disksize (LEAFENTRY le); // this is the same as logsizeof_LEAFENTRY.  The size of a leafentry on disk.
 void wbuf_LEAFENTRY(struct wbuf *w, LEAFENTRY le);

newbrt/logformat.c

@@ -516,7 +516,7 @@ generate_logprint (void) {
 		fprintf(pf, "          u_int32_t actual_murmur = x1764_finish(&checksum);\n");
 		fprintf(pf, "          r = toku_fread_u_int32_t_nocrclen (f, &crc_in_file); len+=4; if (r!=0) return r;\n");
 		fprintf(pf, "          fprintf(outf, \" crc=%%08x\", crc_in_file);\n");
-		fprintf(pf, "          if (crc_in_file!=actual_murmur) fprintf(outf, \" actual_fingerprint=%%08x\", actual_murmur);\n");
+		fprintf(pf, "          if (crc_in_file!=actual_murmur) fprintf(outf, \" checksum=%%08x\", actual_murmur);\n");
 		fprintf(pf, "          r = toku_fread_u_int32_t_nocrclen (f, &len_in_file); len+=4; if (r!=0) return r;\n");
 		fprintf(pf, "          fprintf(outf, \" len=%%u\", len_in_file);\n");
 		fprintf(pf, "          if (len_in_file!=len) fprintf(outf, \" actual_len=%%u\", len);\n");

newbrt/tests/brt-serialize-test.c

@@ -23,7 +23,6 @@ test_serialize_nonleaf(void) {
     int fd = open(__FILE__ ".brt", O_RDWR|O_CREAT|O_BINARY, S_IRWXU|S_IRWXG|S_IRWXO); assert(fd >= 0);
 
     int r;
-    const u_int32_t randval = random();
 
     //    source_brt.fd=fd;
     char *hello_string;
@@ -34,8 +33,6 @@ test_serialize_nonleaf(void) {
     sn.layout_version = BRT_LAYOUT_VERSION;
     sn.layout_version_original = BRT_LAYOUT_VERSION;
     sn.height = 1;
-    sn.rand4fingerprint = randval;
-    sn.local_fingerprint = 0;
     sn.u.n.n_children = 2;
     hello_string = toku_strdup("hello");
     MALLOC_N(2, sn.u.n.childinfos);
@@ -44,8 +41,6 @@ test_serialize_nonleaf(void) {
     sn.u.n.totalchildkeylens = 6;
     BNC_BLOCKNUM(&sn, 0).b = 30;
     BNC_BLOCKNUM(&sn, 1).b = 35;
-    BNC_SUBTREE_FINGERPRINT(&sn, 0) = random();
-    BNC_SUBTREE_FINGERPRINT(&sn, 1) = random();
     BNC_SUBTREE_ESTIMATES(&sn, 0).ndata = random() + (((long long)random())<<32);
     BNC_SUBTREE_ESTIMATES(&sn, 1).ndata = random() + (((long long)random())<<32);
     BNC_SUBTREE_ESTIMATES(&sn, 0).nkeys = random() + (((long long)random())<<32);
@@ -65,9 +60,9 @@ test_serialize_nonleaf(void) {
     r = xids_create_child(xids_123, &xids_234, (TXNID)234);
     CKERR(r);
 
-    r = toku_fifo_enq(BNC_BUFFER(&sn,0), "a", 2, "aval", 5, BRT_NONE, xids_0);   assert(r==0);    sn.local_fingerprint += randval*toku_calc_fingerprint_cmd(BRT_NONE, xids_0, "a", 2, "aval", 5);
-    r = toku_fifo_enq(BNC_BUFFER(&sn,0), "b", 2, "bval", 5, BRT_NONE, xids_123); assert(r==0);    sn.local_fingerprint += randval*toku_calc_fingerprint_cmd(BRT_NONE, xids_123,  "b", 2, "bval", 5);
-    r = toku_fifo_enq(BNC_BUFFER(&sn,1), "x", 2, "xval", 5, BRT_NONE, xids_234); assert(r==0);    sn.local_fingerprint += randval*toku_calc_fingerprint_cmd(BRT_NONE, xids_234, "x", 2, "xval", 5);
+    r = toku_fifo_enq(BNC_BUFFER(&sn,0), "a", 2, "aval", 5, BRT_NONE, xids_0);   assert(r==0);  
+    r = toku_fifo_enq(BNC_BUFFER(&sn,0), "b", 2, "bval", 5, BRT_NONE, xids_123); assert(r==0);
+    r = toku_fifo_enq(BNC_BUFFER(&sn,1), "x", 2, "xval", 5, BRT_NONE, xids_234); assert(r==0);
     BNC_NBYTESINBUF(&sn, 0) = 2*(BRT_CMD_OVERHEAD+KEY_VALUE_OVERHEAD+2+5) + xids_get_serialize_size(xids_0) + xids_get_serialize_size(xids_123);
     BNC_NBYTESINBUF(&sn, 1) = 1*(BRT_CMD_OVERHEAD+KEY_VALUE_OVERHEAD+2+5) + xids_get_serialize_size(xids_234);
     sn.u.n.n_bytes_in_buffers = 3*(BRT_CMD_OVERHEAD+KEY_VALUE_OVERHEAD+2+5) + xids_get_serialize_size(xids_0) + xids_get_serialize_size(xids_123) + xids_get_serialize_size(xids_234);
@@ -112,23 +107,12 @@ test_serialize_nonleaf(void) {
     assert(dn->layout_version_original ==BRT_LAYOUT_VERSION);
     assert(dn->layout_version_read_from_disk ==BRT_LAYOUT_VERSION);
     assert(dn->height == 1);
-    assert(dn->rand4fingerprint==randval);
     assert(dn->u.n.n_children==2);
     assert(strcmp(kv_pair_key(dn->u.n.childkeys[0]), "hello")==0);
     assert(toku_brt_pivot_key_len(dn->u.n.childkeys[0])==6);
     assert(dn->u.n.totalchildkeylens==6);
     assert(BNC_BLOCKNUM(dn,0).b==30);
     assert(BNC_BLOCKNUM(dn,1).b==35);
-    {
-	int i;
-	for (i=0; i<2; i++) {
-	    assert(BNC_SUBTREE_FINGERPRINT(dn, i)==BNC_SUBTREE_FINGERPRINT(&sn, i));
-	    assert(BNC_SUBTREE_ESTIMATES(dn, i).nkeys==BNC_SUBTREE_ESTIMATES(&sn, i).nkeys);
-	    assert(BNC_SUBTREE_ESTIMATES(dn, i).ndata==BNC_SUBTREE_ESTIMATES(&sn, i).ndata);
-	    assert(BNC_SUBTREE_ESTIMATES(dn, i).dsize==BNC_SUBTREE_ESTIMATES(&sn, i).dsize);
-	}
-	assert(dn->local_fingerprint==sn.local_fingerprint);
-    }
     toku_brtnode_free(&dn);
 
     kv_pair_free(sn.u.n.childkeys[0]);

newbrt/tests/test-del-inorder.c

@@ -17,7 +17,6 @@ char *fname;
 static void
 doit (void) {
     BLOCKNUM nodea,nodeb;
-    u_int32_t fingerprinta=0;
 
     int r;
     
@@ -35,11 +34,10 @@ doit (void) {
     r = toku_testsetup_leaf(t, &nodea);
     assert(r==0);
 
-    r = toku_testsetup_nonleaf(t, 1, &nodeb, 1, &nodea, &fingerprinta, 0, 0);
+    r = toku_testsetup_nonleaf(t, 1, &nodeb, 1, &nodea, 0, 0);
     assert(r==0);
 
-    u_int32_t fingerprint=0;
-    r = toku_testsetup_insert_to_nonleaf(t, nodeb, BRT_DELETE_ANY, "hello", 6, 0, 0, &fingerprint);
+    r = toku_testsetup_insert_to_nonleaf(t, nodeb, BRT_DELETE_ANY, "hello", 6, 0, 0);
     assert(r==0);
 
     r = toku_testsetup_root(t, nodeb);

newbrt/tests/test-inc-split.c

@@ -43,7 +43,6 @@ char *fname;
 static void
 doit (int ksize __attribute__((__unused__))) {
     BLOCKNUM cnodes[BRT_FANOUT], bnode, anode;
-    u_int32_t fingerprints[BRT_FANOUT];
 
     char *keys[BRT_FANOUT-1];
     int keylens[BRT_FANOUT-1];
@@ -64,12 +63,11 @@ doit (int ksize __attribute__((__unused__))) {
     for (i=0; i<BRT_FANOUT; i++) {
 	r=toku_testsetup_leaf(t, &cnodes[i]);
 	assert(r==0);
-	fingerprints[i]=0;
 	char key[KSIZE+10];
 	int keylen = 1+snprintf(key, KSIZE, "%08d%0*d", i*10000+1, KSIZE-9, 0);
 	char val[1];
 	char vallen=0;
-	r=toku_testsetup_insert_to_leaf(t, cnodes[i], key, keylen, val, vallen, &fingerprints[i]);
+	r=toku_testsetup_insert_to_leaf(t, cnodes[i], key, keylen, val, vallen);
 	assert(r==0);
     }
 
@@ -80,14 +78,13 @@ doit (int ksize __attribute__((__unused__))) {
 	keys[i]=toku_strdup(key);
     }
 
-    r = toku_testsetup_nonleaf(t, 1, &bnode, BRT_FANOUT, cnodes, fingerprints, keys, keylens);
+    r = toku_testsetup_nonleaf(t, 1, &bnode, BRT_FANOUT, cnodes, keys, keylens);
     assert(r==0);
 
     for (i=0; i+1<BRT_FANOUT; i++) {
 	toku_free(keys[i]);
     }
 
-    u_int32_t bfingerprint=0;
     {
 	const int magic_size = (NODESIZE-toku_testsetup_get_sersize(t, bnode))/2-25;
 	//printf("magic_size=%d\n", magic_size);
@@ -95,22 +92,22 @@ doit (int ksize __attribute__((__unused__))) {
 	int keylen = 1+snprintf(key, KSIZE, "%08d%0*d", 150002, magic_size, 0);
 	char val[1];
 	char vallen=0;
-	r=toku_testsetup_insert_to_nonleaf(t, bnode, BRT_INSERT, key, keylen, val, vallen, &bfingerprint);
+	r=toku_testsetup_insert_to_nonleaf(t, bnode, BRT_INSERT, key, keylen, val, vallen);
 
 	keylen = 1+snprintf(key, KSIZE, "%08d%0*d", 2, magic_size-1, 0);
-	r=toku_testsetup_insert_to_nonleaf(t, bnode, BRT_INSERT, key, keylen, val, vallen, &bfingerprint);	
+	r=toku_testsetup_insert_to_nonleaf(t, bnode, BRT_INSERT, key, keylen, val, vallen);
     }
     //printf("%lld sersize=%d\n", bnode, toku_testsetup_get_sersize(t, bnode));
     // Now we have an internal node which has full children and the buffers are nearly full
 
-    r = toku_testsetup_nonleaf(t, 2, &anode, 1,          &bnode, &bfingerprint,    0, 0);
+    r = toku_testsetup_nonleaf(t, 2, &anode, 1,          &bnode, 0, 0);
     assert(r==0);
     {
 	char key[20];
 	int keylen = 1+snprintf(key, 20, "%08d", 3);
 	char val[1];
 	char vallen=0;
-	r=toku_testsetup_insert_to_nonleaf(t, anode, BRT_INSERT, key, keylen, val, vallen, &bfingerprint); 
+	r=toku_testsetup_insert_to_nonleaf(t, anode, BRT_INSERT, key, keylen, val, vallen);
     }
     if (0)
     {