Write leafentry code, and get things to compile. Addresses #558.

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

newbrt/Makefile

@@ -91,13 +91,39 @@ BINS =  $(REGRESSION_TESTS) \
         tdb_logprint \
 # This line intentially kept commented so I can have a \ on the end of the previous line
 
+OFILES = \
+  brt-serialize.o \
+  brt-verify.o \
+  brt.o \
+  cachetable.o \
+  fifo.o gpma.o \
+  fingerprint.o \
+  key.o \
+  leafentry.o \
+  log.o \
+  log_code.o \
+  memory.o \
+  mempool.o \
+  primes.o \
+  recover.o \
+  roll.o \
+  toku_assert.o \
+  ybt.o \
+# keep this line so I can ha vea \ on the previous line
+
+TEST_OFILES = \
+  $(OFILES) \
+  brt-test-helpers.o \
+# keep this line
+
+
 tdb_logprint: LDFLAGS+=-lz
 tdb_logprint.o: log-internal.h brttypes.h yerror.h log.h kv-pair.h log_header.h
-tdb_logprint: log_code.o memory.o log.o brt-serialize.o fifo.o gpma.o ybt.o fingerprint.o mempool.o primes.o toku_assert.o roll.o brt.o cachetable.o brt-verify.o key.o
+tdb_logprint: $(OFILES)
 
 tdb-recover: LDFLAGS+=-lz
 recover.o: log_header.h log-internal.h log.h yerror.h brttypes.h kv-pair.h memory.h key.h
-tdb-recover: tdb-recover.o recover.o log_code.o memory.o log.o brt-serialize.o fifo.o gpma.o ybt.o fingerprint.o mempool.o primes.o toku_assert.o cachetable.o brt.o brt-verify.o key.o roll.o
+tdb-recover: $(OFILES)
 
 roll.o: log_header.h log-internal.h log.h yerror.h brttypes.h kv-pair.h memory.h key.h cachetable.h gpma.h
 
@@ -152,12 +178,13 @@ check-fanout:
 log-test log-test2 log-test3 log-test4 log-test5 log-test6 benchmark-test brt-test brt-test0 brt-test1 brt-test2 brt-test3 brt-test4 test-brt-overflow brt-test-named-db brt-test-cursor brt-test-cursor-2 test-brt-delete-both brt-serialize-test brtdump test-inc-split test-del-inorder: LDFLAGS+=-lz
 # pma: PROF_FLAGS=-fprofile-arcs -ftest-coverage
 
-BRT_INTERNAL_H_INCLUDES = brt-internal.h cachetable.h fifo.h gpma.h brt.h brt-search.h brttypes.h yerror.h ybt.h log.h ../include/db.h kv-pair.h memory.h crc.h mempool.h
+BRT_INTERNAL_H_INCLUDES = brt-internal.h cachetable.h fifo.h gpma.h brt.h brt-search.h brttypes.h yerror.h ybt.h log.h ../include/db.h kv-pair.h memory.h crc.h mempool.h leafentry.h
 key.o: brttypes.h key.h
 list-test: list-test.o toku_assert.o
-test-brt-delete-both: ybt.o brt.o fifo.o gpma.o memory.o brt-serialize.o cachetable.o ybt.o key.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
-test-inc-split: test-inc-split.o brt.o brt-test-helpers.o toku_assert.o key.o ybt.o cachetable.o memory.o log.o gpma.o log_code.o fifo.o fingerprint.o brt-serialize.o brt-verify.o roll.o primes.o mempool.o
-test-del-inorder: test-del-inorder.o brt.o brt-test-helpers.o toku_assert.o key.o ybt.o cachetable.o memory.o log.o gpma.o log_code.o fifo.o fingerprint.o brt-serialize.o brt-verify.o roll.o primes.o mempool.o
+test-brt-delete-both: ybt.o brt.o fifo.o gpma.o memory.o leafentry.o brt-serialize.o cachetable.o ybt.o key.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
+test-inc-split: $(TEST_OFILES)
+brt-test-helpers.o: $(BRT_INTERNAL_H_INCLUDES) toku_assert.h
+test-del-inorder: $(TEST_OFILES)
 # pma-test.o: $(BRT_INTERNAL_H_INCLUDES) pma-internal.h gpma.h list.h mempool.h
 # pma-test: pma.o memory.o key.o ybt.o log.o mempool.o fingerprint.o brt-serialize.o fifo.o primes.o toku_assert.o log_code.o  roll.o brt.o cachetable.o brt-verify.o
 pma.o: gpma.h yerror.h pma-internal.h memory.h key.h ybt.h brttypes.h log.h ../include/db.h log_header.h
@@ -172,10 +199,10 @@ ybt.o: ybt.h brttypes.h ../include/db.h
 ybt-test: ybt-test.o ybt.o memory.o toku_assert.o
 ybt-test.o: ybt.h ../include/db.h
 cachetable.o: cachetable.h hashfun.h memory.h
-brt-test0 brt-test1 brt-test2 brt-test3 brt-test4 test-brt-overflow brt-test-named-db brt-test-cursor brt-test-cursor-2 brt-test: ybt.o brt.o fifo.o gpma.o memory.o brt-serialize.o cachetable.o ybt.o key.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
+brt-test0 brt-test1 brt-test2 brt-test3 brt-test4 test-brt-overflow brt-test-named-db brt-test-cursor brt-test-cursor-2 brt-test: ybt.o brt.o fifo.o gpma.o leafentry.o memory.o brt-serialize.o cachetable.o ybt.o key.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
 log.o: log_header.h log-internal.h log.h wbuf.h crc.h brttypes.h $(BRT_INTERNAL_H_INCLUDES)
 logformat: logformat.o toku_assert.o
-brt-test0.o brt-test1.o brt-test2.o brt-test3.o brt-test4.o test-brt-overflow.h brt-test-named-db.o brt-test-cursor.o brt-test-cursor-2.o brt-test.o brt.o: brt.h brt-search.h ../include/db.h fifo.h gpma.h brttypes.h cachetable.h memory.h
+brt-test0.o brt-test1.o brt-test2.o brt-test3.o brt-test4.o test-brt-overflow.h brt-test-named-db.o brt-test-cursor.o brt-test-cursor-2.o brt-test.o brt.o: brt.h brt-search.h ../include/db.h fifo.h gpma.h brttypes.h cachetable.h memory.h $(BRT_INTERNAL_H_INCLUDES)
 brt-serialize-test.o: $(BRT_INTERNAL_H_INCLUDES)
 brt.o: $(BRT_INTERNAL_H_INCLUDES) key.h log_header.h
 fifo.o: fifo.h brttypes.h 
@@ -185,13 +212,13 @@ fifo-test-exp fifo-test: fifo.o memory.o toku_assert.o ybt.o
 brt-serialize.o: $(BRT_INTERNAL_H_INCLUDES) key.h wbuf.h rbuf.h
 brt-bigtest: memory.o ybt.o brt.o gpma.o cachetable.o key.o fifo.o brt-serialize.o
 brt-bigtest.o: brt.h brt-search.h ../include/db.h
-log-test6 log-test5 log-test4 log-test3 log-test2 log-test: log.o memory.o toku_assert.o roll.o log_code.o brt-serialize.o brt.o cachetable.o gpma.o ybt.o fifo.o key.o fingerprint.o brt-verify.o mempool.o primes.o
+log-test6 log-test5 log-test4 log-test3 log-test2 log-test: log.o memory.o leafentry.o toku_assert.o roll.o log_code.o brt-serialize.o brt.o cachetable.o gpma.o ybt.o fifo.o key.o fingerprint.o brt-verify.o mempool.o primes.o
 brt-verify.o: $(BRT_INTERNAL_H_INCLUDES)
 fingerprint.o: $(BRT_INTERNAL_H_INCLUDES)
 mempool.o: toku_assert.h mempool.h
 toku_assert.o: toku_assert.h
 
-brt-serialize-test: brt-serialize-test.o brt-serialize.o memory.o fifo.o gpma.o key.o ybt.o brt.o cachetable.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
+brt-serialize-test: brt-serialize-test.o brt-serialize.o leafentry.o memory.o fifo.o gpma.o key.o ybt.o brt.o cachetable.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o 
 test_toku_malloc_plain_free: memory.o toku_assert.o
 
 
@@ -201,14 +228,14 @@ cachetable-test: cachetable.o memory.o cachetable-test.o primes.o toku_assert.o
 cachetable-test2.o: cachetable.h memory.h
 cachetable-test2: cachetable.o memory.o cachetable-test2.o primes.o toku_assert.o
 
-benchmark-test: benchmark-test.o ybt.o memory.o brt.o gpma.o cachetable.o key.o fifo.o brt-serialize.o primes.o toku_assert.o log.o mempool.o brt-verify.o fingerprint.o log_code.o roll.o
+benchmark-test: $(OFILES)
 benchmark-test.o: brt.h brt-search.h ../include/db.h
 
 test-primes: test-primes.o toku_assert.o primes.o toku_assert.o toku_assert.o
 
 test-assert: test-assert.o toku_assert.o
 
-brtdump: brtdump.o brt-serialize.o memory.o gpma.o key.o fingerprint.o log.o log_code.o roll.o cachetable.o primes.o toku_assert.o brt.o ybt.o fifo.o mempool.o brt-verify.o
+brtdump: $(OFILES)
 
 test_oexcl: test_oexcl.o toku_assert.o
 

newbrt/brt-internal.h

@@ -13,6 +13,7 @@
 #include "list.h"
 #include "mempool.h"
 #include "kv-pair.h"
+#include "leafentry.h"
 
 #ifndef BRT_FANOUT
 #define BRT_FANOUT 16
@@ -200,17 +201,8 @@ int toku_set_func_fsync (int (*fsync_function)(int));
 //    return kv;
 //}
 
-int toku_brtnode_compress_kvspace (GPMA pma, struct mempool *mp);
-
 static inline struct kv_pair *brtnode_malloc_kv_pair (GPMA pma, struct mempool *mp, const void *key, unsigned int keylen, const void *val, unsigned int vallen) {
-    struct kv_pair *kv = toku_mempool_malloc(mp, sizeof (struct kv_pair) + keylen + vallen, 4);
-    if (kv == 0) {
-	if (0 == toku_brtnode_compress_kvspace (pma, mp)) {
-	    kv = toku_mempool_malloc(mp, sizeof (struct kv_pair) + keylen + vallen, 4);
-	    toku_verify_gpma(pma);
-	    assert(kv);
-	}
-    }
+    struct kv_pair *kv = mempool_malloc_from_gpma(pma, mp, sizeof (struct kv_pair) + keylen + vallen);
     kv_pair_init(kv, key, keylen, val, vallen);
     return kv;
 }

newbrt/brt.c

@@ -38,6 +38,7 @@
 #include "log_header.h"
 #include "kv-pair.h"
 #include "mempool.h"
+#include "leafentry.h"
 
 extern long long n_items_malloced;
 
@@ -348,7 +349,7 @@ int move_between_mempools (u_int32_t len, void *odata, void **ndata, void *extra
     assert(ms->from->height==0);
     assert(ms->to->height==0);
     assert(len==(unsigned)kv_pair_size(odata));
-    void *newitem=toku_mempool_malloc(&ms->to->u.l.buffer_mempool, len, 4);
+    void *newitem=mempool_malloc_from_gpma(ms->to->u.l.buffer, &ms->to->u.l.buffer_mempool, len);
     assert(newitem);
     memcpy(newitem, odata, len);
     toku_mempool_mfree(&ms->from->u.l.buffer_mempool, odata, len);
@@ -1122,28 +1123,6 @@ int toku_brtleaf_compare_fun (u_int32_t alen __attribute__((__unused__)), void *
     }
 }
 
-int toku_brtnode_compress_kvspace (GPMA pma, struct mempool *memp) {
-    if (toku_mempool_get_frag_size(memp) == 0)
-        return -1;
-    void *newmem = toku_malloc(memp->size);
-    if (newmem == 0)
-        return -2;
-    struct mempool new_kvspace;
-    toku_mempool_init(&new_kvspace, newmem, memp->size);
-    GPMA_ITERATE(pma, idx, len, data,
-		 ({
-		     void *newdata = toku_mempool_malloc(&new_kvspace, len, 4);
-		     assert(newdata);
-		     memcpy(newdata, data, len);
-		     toku_gpma_set_at_index(pma, idx, len, newdata);
-		     // toku_verify_gpma(pma);
-		 }));
-    toku_free(memp->base);
-    *memp = new_kvspace;
-    // toku_verify_gpma(pma);
-    return 0;
-}
-
 static int brt_leaf_put_cmd (BRT t, BRTNODE node, BRT_CMD cmd,
 			     int *did_split, BRTNODE *nodea, BRTNODE *nodeb, DBT *splitk,
 			     int debug,

newbrt/leafentry.c

+#include "brttypes.h"
+#include "crc.h"
+#include "leafentry.h"
+#include "memory.h"
+#include "toku_assert.h"
+
+#include <arpa/inet.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum le_state { LE_COMMITTED=1, // A committed pair.
+		LE_BOTH,        // A committed pair and a provisional pair.
+		LE_PROVDEL,     // A committed pair that has been provisionally deleted
+		LE_PROVPAIR };  // No committed value, but a provisional pair.
+
+struct leafentry {
+    char state;
+    char contents[0];
+} __attribute__((packed));
+
+struct contents_committed {
+    u_int32_t keylen;
+    u_int32_t vallen;
+    char *data[0];
+} __attribute__((packed));
+
+struct contents_both {
+    TXNID xid;
+    u_int32_t keylen;
+    u_int32_t committed_vallen;
+    u_int32_t prov_vallen;
+    char *data[0];
+} __attribute__((packed));
+
+struct contents_provdelorpair { // Te PROVDEL or PROVPAIR cases
+    TXNID xid;
+    u_int32_t keylen;
+    u_int32_t vallen;
+    char *data[0];
+} __attribute__((packed));
+
+static u_int32_t committed_keylen (void*cev) {
+    struct contents_committed *ce=cev;
+    return ce->keylen;
+}
+
+static void* committed_key (void*cev) {
+    struct contents_committed *ce=cev;
+    return &ce->data[0];
+}
+
+static u_int32_t committed_vallen (struct contents_committed *ce) {
+    return ce->vallen;
+}
+
+static void* committed_val (struct contents_committed *ce) {
+    return &ce->data[ce->keylen];
+}
+
+static TXNID both_xid (struct contents_both *ce) {
+    return ce->xid;
+}
+
+static u_int32_t both_keylen (struct contents_both *ce) {
+    return ce->keylen;
+}
+
+static u_int32_t both_committed_vallen (struct contents_both *ce) {
+    return ce->committed_vallen;
+}
+
+static u_int32_t both_prov_vallen (struct contents_both *ce) {
+    return ce->prov_vallen;
+}
+
+static void* both_key (struct contents_both *ce) {
+    return &ce->data[0];
+}
+
+static void* both_committed_val (struct contents_both *ce) {
+    return &ce->data[ce->keylen];
+}
+
+static void* both_prov_val (struct contents_both*ce) {
+    return &ce->data[ce->keylen+ce->committed_vallen];
+}
+
+static TXNID provdelorpair_xid (struct contents_provdelorpair *ce) {
+    return ce->xid;
+}
+
+static u_int32_t provdelorpair_keylen (struct contents_provdelorpair *ce) {
+    return ce->keylen;
+}
+
+static u_int32_t provdelorpair_vallen (struct contents_provdelorpair *ce) {
+    return ce->vallen;
+}
+
+static void* provdelorpair_key (struct contents_provdelorpair *ce) {
+    return &ce->data[0];
+}
+
+static void* provdelorpair_val (struct contents_provdelorpair *ce) {
+    return &ce->data[ce->keylen];
+}
+
+
+#define LESWITCHCALL(le,funname, ...) ({	\
+  switch((enum le_state)((le)->state)) {	\
+  case LE_COMMITTED: return funname ## _le_committed( committed_keylen((struct contents_committed*)&(le)->contents), \
+						      committed_key((struct contents_committed*)&(le)->contents),    \
+						      committed_vallen((struct contents_committed*)&(le)->contents), \
+						      committed_val((struct contents_committed*)&(le)->contents), \
+                                                      ## __VA_ARGS__);                   \
+  case LE_BOTH:   return funname ## _le_both( both_xid((struct contents_both*)&(le)->contents),                 \
+					      both_keylen((struct contents_both*)&(le)->contents),              \
+					      both_key((struct contents_both*)&(le)->contents),                 \
+					      both_committed_vallen((struct contents_both*)&(le)->contents),    \
+					      both_committed_val((struct contents_both*)&(le)->contents),       \
+					      both_prov_vallen((struct contents_both*)&(le)->contents),         \
+					      both_prov_val((struct contents_both*)&(le)->contents), \
+                                                      ## __VA_ARGS__);                   \
+  case LE_PROVDEL: return funname ## _le_provdel ( provdelorpair_xid((struct contents_provdelorpair*)&(le)->contents), \
+						  provdelorpair_keylen((struct contents_provdelorpair*)&(le)->contents), \
+						  provdelorpair_key((struct contents_provdelorpair*)&(le)->contents),    \
+						  provdelorpair_vallen((struct contents_provdelorpair*)&(le)->contents), \
+						  provdelorpair_val((struct contents_provdelorpair*)&(le)->contents),    \
+                                                      ## __VA_ARGS__);                   \
+  case LE_PROVPAIR: return funname ## _le_provpair(provdelorpair_xid((struct contents_provdelorpair*)&(le)->contents),    \
+						  provdelorpair_keylen((struct contents_provdelorpair*)&(le)->contents), \
+						  provdelorpair_key((struct contents_provdelorpair*)&(le)->contents),    \
+						  provdelorpair_vallen((struct contents_provdelorpair*)&(le)->contents), \
+						  provdelorpair_val((struct contents_provdelorpair*)&(le)->contents),    \
+                                                      ## __VA_ARGS__);                   \
+  } abort(); })
+
+static u_int32_t crc_uint32_t (u_int32_t crc, u_int32_t v) {
+    u_int32_t i = htonl(v);
+    return toku_crc32(crc, &i, 4);
+}
+
+static u_int32_t crc_uint64_t (u_int32_t crc, u_int64_t v) {
+    crc = crc_uint32_t (crc, v>>32);
+    crc = crc_uint32_t (crc, v&0xffffffff);
+    return crc;
+}
+
+static u_int32_t crc_dbt (u_int32_t crc, u_int32_t len, void *data) {
+    crc = crc_uint32_t(crc, len);
+    crc = toku_crc32(crc, data, len);
+    return crc;
+}
+
+static u_int32_t crc_le_committed(u_int32_t keylen, void *key, u_int32_t vallen, void *val, u_int32_t crc) {
+    crc = crc_dbt(crc, keylen, key);
+    crc = crc_dbt(crc, vallen, val);
+    return crc;
+}
+
+static u_int32_t crc_le_both(TXNID xid, u_int32_t keylen, void *key, u_int32_t cvallen, void *cval, u_int32_t pvallen, void *pval, u_int32_t crc) {
+    crc = crc_uint64_t(crc, xid);
+    crc = crc_dbt(crc, keylen, key);
+    crc = crc_dbt(crc, cvallen, cval);
+    crc = crc_dbt(crc, pvallen, pval);
+    return crc;
+}
+
+static u_int32_t crc_le_provdel(TXNID xid, u_int32_t keylen, void *key, u_int32_t vallen, void *val, u_int32_t crc) {
+    crc = crc_uint64_t(crc, xid);
+    crc = crc_dbt(crc, keylen, key);
+    crc = crc_dbt(crc, vallen, val);
+    return crc;
+}
+
+static u_int32_t crc_le_provpair(TXNID xid, u_int32_t keylen, void *key, u_int32_t vallen, void *val, u_int32_t crc) {
+    return crc_le_provdel(xid, keylen, key, vallen, val, crc);
+}
+
+u_int32_t toku_le_crc(LEAFENTRY v) {
+    u_int32_t crc = toku_null_crc;
+    crc = toku_crc32(crc, &v->state, 1);
+    LESWITCHCALL(v, crc, crc);
+}
+
+int toku_gpma_compress_kvspace (GPMA pma, struct mempool *memp) {
+    if (toku_mempool_get_frag_size(memp) == 0)
+        return -1;
+    void *newmem = toku_malloc(memp->size);
+    if (newmem == 0)
+        return -2;
+    struct mempool new_kvspace;
+    toku_mempool_init(&new_kvspace, newmem, memp->size);
+    GPMA_ITERATE(pma, idx, len, data,
+		 ({
+		     void *newdata = toku_mempool_malloc(&new_kvspace, len, 4);
+		     assert(newdata);
+		     memcpy(newdata, data, len);
+		     toku_gpma_set_at_index(pma, idx, len, newdata);
+		     // toku_verify_gpma(pma);
+		 }));
+    toku_free(memp->base);
+    *memp = new_kvspace;
+    // toku_verify_gpma(pma);
+    return 0;
+}
+
+
+void *mempool_malloc_from_gpma(GPMA pma, struct mempool *mp, u_int32_t size) {
+    void *v = toku_mempool_malloc(mp, size, 4);
+    if (v==0) {
+	if (0 == toku_gpma_compress_kvspace(pma, mp)) {
+	    v = toku_mempool_malloc(mp, size, 4);
+	    assert(v);
+	}
+    }
+    return v;
+}
+
+int le_committed (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, GPMA pma, struct mempool *mp, LEAFENTRY *result) {
+    struct contents_committed *ce;
+    LEAFENTRY le=mempool_malloc_from_gpma(pma, mp, sizeof(*le)+sizeof(*ce)+klen+dlen);
+    le->state=LE_COMMITTED;
+    ce=(struct contents_committed*)&le->contents[0];
+    ce->keylen = klen;
+    ce->vallen = dlen;
+    memcpy(&ce->data[0], kval, klen);
+    memcpy(&ce->data[klen], dval, dlen);
+    *result=le;
+    return 0;
+}
+int le_both (ITEMLEN cklen, bytevec ckval, ITEMLEN cdlen, bytevec cdval, ITEMLEN pdlen, bytevec pdval,
+	     struct mempool *mp, LEAFENTRY *result);
+int le_provdel  (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, struct mempool *mp, LEAFENTRY *result);
+int le_provpair (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, struct mempool *mp, LEAFENTRY *result);

newbrt/leafentry.h

+#ifndef LEAFENTRY_H
+#define LEAFENTRY_H
+#ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
+
+/* In the past, leaves simply contained key-value pairs.
+ * In this implementatoin, leaf values are more complex
+ * They can contain a committed value:
+ *   - Which can be "not-present",
+ *   - Or a key-value pair.
+ * They can contain a provisional value, which depends on whether a particular transaction commits or aborts.
+ *   - A not-present value
+ *   - Or a key-value pair.
+ *   - Or there can be no provisional value at all (that is, the value doesn't depend on the transaction.)
+ * Note that if both the provisional value and the committed value are not-present, then there is simply no entry in the leaf.
+ * So let's enumerate the possibilities:
+ *     committed pair                                 A committed pair unaffected by any incomplete transaction.
+ *     committed pair and provisional pair            A committed pair to provisionally be replaced by a new pair.
+ *     committed pair and provisional delete          A committed pair that will be deleted
+ *     provisional pair                               No committed pair, but if a provisional pair to add.
+ *
+ * In the case of a committed pair and a provisional pair, the key is the same in both cases.  The value can be different.
+ *
+ * For DUPSORT databases, the key-value pair is everything, so we need only represent the key-value pair once.  So the cases are
+ *    committed pair
+ *    committed pair provisionally deleted
+ *    provisional pair
+ * The case of a committed pair and a provisional pair can be represented by a committed pair, since it doesn't matter whether the transction aborts or commits, the value is the same.
+ */
+
+#include "mempool.h"
+#include "brttypes.h"
+#include "gpma.h"
+
+typedef struct leafentry *LEAFENTRY;
+
+u_int32_t le_crc(LEAFENTRY v);
+
+int le_committed (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, GPMA pma, struct mempool *mp, LEAFENTRY *result);
+int le_both (ITEMLEN cklen, bytevec ckval, ITEMLEN cdlen, bytevec cdval, ITEMLEN pdlen, bytevec pdval,
+	     struct mempool *mp, LEAFENTRY *result);
+int le_provdel  (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, struct mempool *mp, LEAFENTRY *result);
+int le_provpair (ITEMLEN klen, bytevec kval, ITEMLEN dlen, bytevec dval, struct mempool *mp, LEAFENTRY *result);
+
+int toku_gpma_compress_kvspace (GPMA pma, struct mempool *memp);
+void *mempool_malloc_from_gpma(GPMA pma, struct mempool *mp, u_int32_t size);
+
+#endif
+

newbrt/recover.c

@@ -507,13 +507,7 @@ int move_indices (GPMA from, struct mempool *from_mempool,
 	if (from==to) {
 	    to->items[to_idx] = items[i];
 	} else {
-	    void *new_data = toku_mempool_malloc(to_mempool, items[i].len, 4);
-	    if (new_data==0) {
-		int r = toku_brtnode_compress_kvspace(to, to_mempool);
-		assert(r==0);
-		new_data = toku_mempool_malloc(to_mempool, items[i].len, 4);
-		assert(new_data);
-	    }
+	    void *new_data = mempool_malloc_from_gpma(to, to_mempool, items[i].len);
 	    memcpy(new_data, items[i].data, items[i].len);
 	    to->items[to_idx] = (struct gitem){items[i].len, new_data};
 	    toku_mempool_mfree(from_mempool, items[i].data, items[i].len);

src/Makefile

@@ -58,7 +58,7 @@ clean:
 
 ydb.o: ../include/db.h ../newbrt/cachetable.h ../newbrt/brt.h ../newbrt/log.c
 
-DBBINS = ydb.o errors.o elocks.o ../newbrt/brt.o ../newbrt/brt-serialize.o ../newbrt/brt-verify.o ../newbrt/cachetable.o ../newbrt/fifo.o ../newbrt/key.o ../newbrt/memory.o ../newbrt/mempool.o ../newbrt/gpma.o ../newbrt/ybt.o ../newbrt/primes.o ../newbrt/log.o ../newbrt/fingerprint.o ../newbrt/log_code.o ../newbrt/roll.o ../newbrt/toku_assert.o ../newbrt/recover.o
+DBBINS = ydb.o errors.o elocks.o ../newbrt/brt.o ../newbrt/brt-serialize.o ../newbrt/brt-verify.o ../newbrt/cachetable.o ../newbrt/fifo.o ../newbrt/key.o ../newbrt/leafentry.o ../newbrt/memory.o ../newbrt/mempool.o ../newbrt/gpma.o ../newbrt/ybt.o ../newbrt/primes.o ../newbrt/log.o ../newbrt/fingerprint.o ../newbrt/log_code.o ../newbrt/roll.o ../newbrt/toku_assert.o ../newbrt/recover.o
 
 RANGETREE_BINS = range_tree/rangetree.o range_tree/tokuredblack.o
 LOCKTREE_BINS  = lock_tree/locktree.o lock_tree/rth.o lock_tree/lth.o lock_tree/idlth.o lock_tree/db_id.o $(RANGETREE_BINS)