FT-271 Move block allocator code into a class.

ft/ft-cachetable-wrappers.cc

@@ -89,6 +89,7 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 "ft/block_table.h"
 #include "ft/fttypes.h"
 #include "ft/ft-cachetable-wrappers.h"
 #include "ft/ft-flusher.h"

ft/ft-flusher.cc

@@ -89,6 +89,7 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 "ft/block_table.h"
 #include "ft/ft.h"
 #include "ft/ft-cachetable-wrappers.h"
 #include "ft/ft-internal.h"
@@ -1334,11 +1335,7 @@ maybe_merge_pinned_nodes(
     }
 }
 
-static void merge_remove_key_callback(
-    BLOCKNUM *bp,
-    bool for_checkpoint,
-    void *extra)
-{
+static void merge_remove_key_callback(BLOCKNUM *bp, bool for_checkpoint, void *extra) {
     FT ft = (FT) extra;
     toku_free_blocknum(ft->blocktable, bp, ft, for_checkpoint);
 }

ft/ft-internal.h

@@ -109,7 +109,6 @@ PATENT RIGHTS GRANT:
 #include "toku_list.h"
 #include <util/omt.h>
 #include "leafentry.h"
-#include "block_table.h"
 #include "compress.h"
 #include <util/omt.h>
 #include "ft/bndata.h"
@@ -117,6 +116,7 @@ PATENT RIGHTS GRANT:
 #include "ft/rollback.h"
 #include "ft/msg_buffer.h"
 
+struct block_table;
 struct ft_search;
 
 enum { KEY_VALUE_OVERHEAD = 8 }; /* Must store the two lengths. */
@@ -229,7 +229,7 @@ struct ft {
     // These are not read-only:
 
     // protected by blocktable lock
-    BLOCK_TABLE blocktable;
+    struct block_table *blocktable;
 
     // protected by atomic builtins
     STAT64INFO_S in_memory_stats;
@@ -385,7 +385,7 @@ unsigned int toku_serialize_ftnode_size(FTNODE node); /* How much space will it
 void toku_verify_or_set_counts(FTNODE);
 
 size_t toku_serialize_ft_size (FT_HEADER h);
-void toku_serialize_ft_to (int fd, FT_HEADER h, BLOCK_TABLE blocktable, CACHEFILE cf);
+void toku_serialize_ft_to (int fd, FT_HEADER h, struct block_table *blocktable, CACHEFILE cf);
 void toku_serialize_ft_to_wbuf (
     struct wbuf *wbuf, 
     FT_HEADER h, 

ft/ft-ops.cc

@@ -200,21 +200,22 @@ basement nodes, bulk fetch,  and partial fetch:
 
 */
 
-#include "checkpoint.h"
-#include "cursor.h"
-#include "ft.h"
-#include "ft-cachetable-wrappers.h"
-#include "ft-flusher.h"
-#include "ft-internal.h"
-#include "node.h"
-#include "ft_layout_version.h"
-#include "log-internal.h"
-#include "sub_block.h"
-#include "txn_manager.h"
-#include "leafentry.h"
-#include "xids.h"
-#include "ft_msg.h"
-#include "ule.h"
+#include "ft/block_table.h"
+#include "ft/checkpoint.h"
+#include "ft/cursor.h"
+#include "ft/ft.h"
+#include "ft/ft-cachetable-wrappers.h"
+#include "ft/ft-flusher.h"
+#include "ft/ft-internal.h"
+#include "ft/ft_layout_version.h"
+#include "ft/ft_msg.h"
+#include "ft/leafentry.h"
+#include "ft/log-internal.h"
+#include "ft/node.h"
+#include "ft/sub_block.h"
+#include "ft/txn_manager.h"
+#include "ft/ule.h"
+#include "ft/xids.h"
 
 #include <toku_race_tools.h>
 

ft/ft-serialize.cc

@@ -89,9 +89,10 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 "compress.h"
-#include "ft.h"
-#include "ft-internal.h"
+#include "ft/block_table.h"
+#include "ft/compress.h"
+#include "ft/ft.h"
+#include "ft/ft-internal.h"
 
 // not version-sensitive because we only serialize a descriptor using the current layout_version
 uint32_t
@@ -509,7 +510,7 @@ serialize_ft_min_size (uint32_t version) {
         abort();
     }
 
-    lazy_assert(size <= BLOCK_ALLOCATOR_HEADER_RESERVE);
+    lazy_assert(size <= block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE);
     return size;
 }
 
@@ -586,7 +587,7 @@ int deserialize_ft_from_fd_into_rbuf(int fd,
     //If too big, it is corrupt.  We would probably notice during checksum
     //but may have to do a multi-gigabyte malloc+read to find out.
     //If its too small reading rbuf would crash, so verify.
-    if (size > BLOCK_ALLOCATOR_HEADER_RESERVE || size < min_header_size) {
+    if (size > block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE || size < min_header_size) {
         r = TOKUDB_DICTIONARY_NO_HEADER;
         goto exit;
     }
@@ -675,7 +676,7 @@ toku_deserialize_ft_from(int fd,
         h0_acceptable = true;
     }
 
-    toku_off_t header_1_off = BLOCK_ALLOCATOR_HEADER_RESERVE;
+    toku_off_t header_1_off = block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE;
     r1 = deserialize_ft_from_fd_into_rbuf(fd, header_1_off, &rb_1, &checkpoint_count_1, &checkpoint_lsn_1, &version_1);
     if (r1 == 0 && checkpoint_lsn_1.lsn <= max_acceptable_lsn.lsn) {
         h1_acceptable = true;
@@ -754,7 +755,7 @@ toku_deserialize_ft_from(int fd,
 size_t toku_serialize_ft_size (FT_HEADER h) {
     size_t size = serialize_ft_min_size(h->layout_version);
     //There is no dynamic data.
-    lazy_assert(size <= BLOCK_ALLOCATOR_HEADER_RESERVE);
+    lazy_assert(size <= block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE);
     return size;
 }
 
@@ -816,7 +817,7 @@ void toku_serialize_ft_to (int fd, FT_HEADER h, BLOCK_TABLE blocktable, CACHEFIL
     struct wbuf w_main;
     size_t size_main       = toku_serialize_ft_size(h);
     size_t size_main_aligned = roundup_to_multiple(512, size_main);
-    assert(size_main_aligned<BLOCK_ALLOCATOR_HEADER_RESERVE);
+    assert(size_main_aligned<block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE);
     char *XMALLOC_N_ALIGNED(512, size_main_aligned, mainbuf);
     for (size_t i=size_main; i<size_main_aligned; i++) mainbuf[i]=0; // initialize the end of the buffer with zeros
     wbuf_init(&w_main, mainbuf, size_main);
@@ -844,7 +845,7 @@ void toku_serialize_ft_to (int fd, FT_HEADER h, BLOCK_TABLE blocktable, CACHEFIL
     //Alternate writing header to two locations:
     //   Beginning (0) or BLOCK_ALLOCATOR_HEADER_RESERVE
     toku_off_t main_offset;
-    main_offset = (h->checkpoint_count & 0x1) ? 0 : BLOCK_ALLOCATOR_HEADER_RESERVE;
+    main_offset = (h->checkpoint_count & 0x1) ? 0 : block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE;
     toku_os_full_pwrite(fd, w_main.buf, size_main_aligned, main_offset);
     toku_free(w_main.buf);
     toku_free(w_translation.buf);

ft/ft-verify.cc

@@ -97,10 +97,11 @@ PATENT RIGHTS GRANT:
  *   For each nonleaf node:  All the messages have keys that are between the associated pivot keys ( left_pivot_key < message <= right_pivot_key)
  */
 
-#include "ft-cachetable-wrappers.h"
-#include "ft-internal.h"
-#include "ft.h"
-#include "node.h"
+#include "ft/block_table.h"
+#include "ft/ft.h"
+#include "ft/ft-cachetable-wrappers.h"
+#include "ft/ft-internal.h"
+#include "ft/node.h"
 
 static int 
 compare_pairs (FT_HANDLE ft_handle, const DBT *a, const DBT *b) {

ft/ft.cc

@@ -89,6 +89,7 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 "ft/block_table.h"
 #include "ft/ft.h"
 #include "ft/ft-cachetable-wrappers.h"
 #include "ft/ft-internal.h"
@@ -107,10 +108,10 @@ toku_reset_root_xid_that_created(FT ft, TXNID new_root_xid_that_created) {
 
     // hold lock around setting and clearing of dirty bit
     // (see cooperative use of dirty bit in ft_begin_checkpoint())
-    toku_ft_lock (ft);
+    toku_ft_lock(ft);
     ft->h->root_xid_that_created = new_root_xid_that_created;
     ft->h->dirty = 1;
-    toku_ft_unlock (ft);
+    toku_ft_unlock(ft);
 }
 
 static void

ft/ft_node-serialize.cc

@@ -89,6 +89,7 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 "ft/block_table.h"
 #include "ft/cachetable.h"
 #include "ft/compress.h"
 #include "ft/ft.h"

ft/ftverify.cc

@@ -200,7 +200,7 @@ deserialize_headers(int fd, struct ft **h1p, struct ft **h2p)
         }
     }
     {
-        toku_off_t header_1_off = BLOCK_ALLOCATOR_HEADER_RESERVE;
+        toku_off_t header_1_off = block_allocator::BLOCK_ALLOCATOR_HEADER_RESERVE;
         r1 = deserialize_ft_from_fd_into_rbuf(
             fd,
             header_1_off,

ft/loader/loader.cc

@@ -100,18 +100,19 @@ PATENT RIGHTS GRANT:
 #include <string.h>
 #include <fcntl.h>
 
-#include <util/x1764.h>
-
-#include "loader/loader-internal.h"
-#include "ft-internal.h"
-#include "sub_block.h"
-#include "sub_block_map.h"
-#include "loader/pqueue.h"
-#include "loader/dbufio.h"
-#include "leafentry.h"
-#include "log-internal.h"
-#include "ft.h"
-#include "node.h"
+#include "ft/block_table.h"
+#include "ft/ft.h"
+#include "ft/ft-internal.h"
+#include "ft/leafentry.h"
+#include "ft/loader/loader-internal.h"
+#include "ft/loader/pqueue.h"
+#include "ft/loader/dbufio.h"
+#include "ft/log-internal.h"
+#include "ft/node.h"
+#include "ft/sub_block.h"
+#include "ft/sub_block_map.h"
+
+#include "util/x1764.h"
 
 static size_t (*os_fwrite_fun)(const void *,size_t,size_t,FILE*)=NULL;
 void ft_loader_set_os_fwrite (size_t (*fwrite_fun)(const void*,size_t,size_t,FILE*)) {

ft/logger.cc

@@ -94,12 +94,13 @@ PATENT RIGHTS GRANT:
 #include <limits.h>
 #include <unistd.h>
 
-#include "ft.h"
-#include "log-internal.h"
-#include "txn_manager.h"
-#include "rollback_log_node_cache.h"
+#include "ft/block_table.h"
+#include "ft/ft.h"
+#include "ft/log-internal.h"
+#include "ft/txn_manager.h"
+#include "ft/rollback_log_node_cache.h"
 
-#include <util/status.h>
+#include "util/status.h"
 
 static const int log_format_version=TOKU_LOG_VERSION;
 

ft/rollback-ct-callbacks.cc

@@ -89,15 +89,16 @@ PATENT RIGHTS GRANT:
 #ident "Copyright (c) 2007-2013 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 <toku_portability.h>
-#include <memory.h>
+#include "portability/memory.h"
+#include "portability/toku_portability.h"
 
-#include "ft-internal.h"
-#include "fttypes.h"
-#include "rollback.h"
-#include "rollback-ct-callbacks.h"
+#include "ft/block_table.h"
+#include "ft/ft-internal.h"
+#include "ft/fttypes.h"
+#include "ft/rollback.h"
+#include "ft/rollback-ct-callbacks.h"
 
-#include <util/memarena.h>
+#include "util/memarena.h"
 
 // Address used as a sentinel. Otherwise unused.
 static struct serialized_rollback_log_node cloned_rollback;

ft/rollback.cc

@@ -91,25 +91,21 @@ PATENT RIGHTS GRANT:
 
 #include <toku_stdint.h>
 
-#include "ft.h"
-#include "log-internal.h"
-#include "rollback-ct-callbacks.h"
+#include "ft/block_table.h"
+#include "ft/ft.h"
+#include "ft/log-internal.h"
+#include "ft/rollback-ct-callbacks.h"
 
 static void rollback_unpin_remove_callback(CACHEKEY* cachekey, bool for_checkpoint, void* extra) {
-    FT CAST_FROM_VOIDP(h, extra);
-    toku_free_blocknum(
-        h->blocktable,
-        cachekey,
-        h,
-        for_checkpoint
-        );
+    FT CAST_FROM_VOIDP(ft, extra);
+    toku_free_blocknum(ft->blocktable, cachekey, ft, for_checkpoint);
 }
 
 void toku_rollback_log_unpin_and_remove(TOKUTXN txn, ROLLBACK_LOG_NODE log) {
     int r;
     CACHEFILE cf = txn->logger->rollback_cachefile;
-    FT CAST_FROM_VOIDP(h, toku_cachefile_get_userdata(cf));
-    r = toku_cachetable_unpin_and_remove (cf, log->ct_pair, rollback_unpin_remove_callback, h);
+    FT CAST_FROM_VOIDP(ft, toku_cachefile_get_userdata(cf));
+    r = toku_cachetable_unpin_and_remove (cf, log->ct_pair, rollback_unpin_remove_callback, ft);
     assert(r == 0);
 }
 

ft/tests/block_allocator_test.cc

@@ -91,42 +91,40 @@ PATENT RIGHTS GRANT:
 
 #include "test.h"
 
-static void ba_alloc_at (BLOCK_ALLOCATOR ba, uint64_t size, uint64_t offset) {
-    block_allocator_validate(ba);
-    block_allocator_alloc_block_at(ba, size*512, offset*512);
-    block_allocator_validate(ba);
+static void ba_alloc_at(block_allocator *ba, uint64_t size, uint64_t offset) {
+    ba->validate();
+    ba->alloc_block_at(size * 512, offset * 512);
+    ba->validate();
 }
 
-static void ba_alloc (BLOCK_ALLOCATOR ba, uint64_t size, uint64_t *answer) {
-    block_allocator_validate(ba);
+static void ba_alloc(block_allocator *ba, uint64_t size, uint64_t *answer) {
+    ba->validate();
     uint64_t actual_answer;
-    block_allocator_alloc_block(ba, 512*size, &actual_answer);
-    block_allocator_validate(ba);
+    ba->alloc_block(512 * size, &actual_answer);
+    ba->validate();
+
     assert(actual_answer%512==0);
     *answer = actual_answer/512;
 }
 
-static void ba_free (BLOCK_ALLOCATOR ba, uint64_t offset) {
-    block_allocator_validate(ba);
-    block_allocator_free_block(ba, offset*512);
-    block_allocator_validate(ba);
+static void ba_free(block_allocator *ba, uint64_t offset) {
+    ba->validate();
+    ba->free_block(offset * 512);
+    ba->validate();
 }
 
-static void
-ba_check_l (BLOCK_ALLOCATOR ba, uint64_t blocknum_in_layout_order, uint64_t expected_offset, uint64_t expected_size)
-{
+static void ba_check_l(block_allocator *ba, uint64_t blocknum_in_layout_order,
+                       uint64_t expected_offset, uint64_t expected_size) {
     uint64_t actual_offset, actual_size;
-    int r = block_allocator_get_nth_block_in_layout_order(ba, blocknum_in_layout_order, &actual_offset, &actual_size);
+    int r = ba->get_nth_block_in_layout_order(blocknum_in_layout_order, &actual_offset, &actual_size);
     assert(r==0);
     assert(expected_offset*512 == actual_offset);
     assert(expected_size  *512 == actual_size);
 }
 
-static void
-ba_check_none (BLOCK_ALLOCATOR ba, uint64_t blocknum_in_layout_order)
-{
+static void ba_check_none(block_allocator *ba, uint64_t blocknum_in_layout_order) {
     uint64_t actual_offset, actual_size;
-    int r = block_allocator_get_nth_block_in_layout_order(ba, blocknum_in_layout_order, &actual_offset, &actual_size);
+    int r = ba->get_nth_block_in_layout_order(blocknum_in_layout_order, &actual_offset, &actual_size);
     assert(r==-1);
 }
 
@@ -134,12 +132,13 @@ ba_check_none (BLOCK_ALLOCATOR ba, uint64_t blocknum_in_layout_order)
 // Simple block allocator test
 static void
 test_ba0 (void) {
-    BLOCK_ALLOCATOR ba;
+    block_allocator allocator;
+    block_allocator *ba = &allocator;
     uint64_t b0, b1;
-    create_block_allocator(&ba, 100*512, 1*512);
-    assert(block_allocator_allocated_limit(ba)==100*512);
+    ba->create(100*512, 1*512);
+    assert(ba->allocated_limit()==100*512);
     ba_alloc_at(ba, 50, 100);
-    assert(block_allocator_allocated_limit(ba)==150*512);
+    assert(ba->allocated_limit()==150*512);
     ba_alloc_at(ba, 25, 150);
     ba_alloc   (ba, 10, &b0);
     ba_check_l (ba, 0, 0,   100);
@@ -154,9 +153,9 @@ test_ba0 (void) {
     assert(b0==160);
     ba_alloc(ba, 10, &b0);
     ba_alloc(ba, 113, &b1);
-    assert(113*512==block_allocator_block_size(ba, b1 *512));
-    assert(10 *512==block_allocator_block_size(ba, b0 *512));
-    assert(50 *512==block_allocator_block_size(ba, 100*512));
+    assert(113*512==ba->block_size(b1 *512));
+    assert(10 *512==ba->block_size(b0 *512));
+    assert(50 *512==ba->block_size(100*512));
 
     uint64_t b2, b3, b4, b5, b6, b7;
     ba_alloc(ba, 100, &b2);     
@@ -183,15 +182,15 @@ test_ba0 (void) {
     ba_free(ba, b4);           
     ba_alloc(ba, 100, &b4);    
 
-    destroy_block_allocator(&ba);
-    assert(ba==0);
+    ba->destroy();
 }
 
 // Manually to get coverage of all the code in the block allocator.
 static void
 test_ba1 (int n_initial) {
-    BLOCK_ALLOCATOR ba;
-    create_block_allocator(&ba, 0*512, 1*512);
+    block_allocator allocator;
+    block_allocator *ba = &allocator;
+    ba->create(0*512, 1*512);
     int i;
     int n_blocks=0;
     uint64_t blocks[1000];
@@ -213,19 +212,19 @@ test_ba1 (int n_initial) {
 	}
     }
     
-    destroy_block_allocator(&ba);
-    assert(ba==0);
+    ba->destroy();
 }
     
 // Check to see if it is first fit or best fit.
 static void
 test_ba2 (void)
 {
-    BLOCK_ALLOCATOR ba;
+    block_allocator allocator;
+    block_allocator *ba = &allocator;
     uint64_t b[6];
     enum { BSIZE = 1024 };
-    create_block_allocator(&ba, 100*512, BSIZE*512);
-    assert(block_allocator_allocated_limit(ba)==100*512);
+    ba->create(100*512, BSIZE*512);
+    assert(ba->allocated_limit()==100*512);
     ba_check_l    (ba, 0, 0, 100);
     ba_check_none (ba, 1);
 
@@ -344,7 +343,7 @@ test_ba2 (void)
     ba_alloc(ba, 100, &b11);
     assert(b11==5*BSIZE);
 
-    destroy_block_allocator(&ba);
+    ba->destroy();
 }
 
 int

ft/tests/ft-bfe-query.cc

@@ -435,10 +435,10 @@ test_prefetching(void) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA ndd = NULL;
@@ -450,7 +450,7 @@ test_prefetching(void) {
 
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     ft_h->cmp.destroy();
     toku_free(ft_h->h);

ft/tests/ft-clock-test.cc

@@ -371,10 +371,10 @@ test_serialize_nonleaf(void) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA ndd = NULL;
@@ -387,7 +387,7 @@ test_serialize_nonleaf(void) {
     toku_destroy_ftnode_internals(&sn);
     toku_free(ndd);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     ft_h->cmp.destroy();
@@ -451,10 +451,10 @@ test_serialize_leaf(void) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA ndd = NULL;
@@ -466,7 +466,7 @@ test_serialize_leaf(void) {
 
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);

ft/tests/ft-serialize-benchmark.cc

@@ -211,10 +211,10 @@ test_serialize_leaf(int valsize, int nelts, double entropy, int ser_runs, int de
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
 
@@ -277,7 +277,7 @@ test_serialize_leaf(int valsize, int nelts, double entropy, int ser_runs, int de
 
     toku_ftnode_free(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     ft_h->cmp.destroy();
     toku_free(ft_h->h);
@@ -374,10 +374,10 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy, int ser_runs, int
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
 
@@ -412,7 +412,7 @@ test_serialize_nonleaf(int valsize, int nelts, double entropy, int ser_runs, int
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     ft_h->cmp.destroy();

ft/tests/ft-serialize-test.cc

@@ -315,10 +315,10 @@ test_serialize_leaf_check_msn(enum ftnode_verify_type bft, bool do_clone) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA src_ndd = NULL;
@@ -373,7 +373,7 @@ test_serialize_leaf_check_msn(enum ftnode_verify_type bft, bool do_clone) {
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -448,10 +448,10 @@ test_serialize_leaf_with_large_pivots(enum ftnode_verify_type bft, bool do_clone
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA src_ndd = NULL;
@@ -508,7 +508,7 @@ test_serialize_leaf_with_large_pivots(enum ftnode_verify_type bft, bool do_clone
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -574,10 +574,10 @@ test_serialize_leaf_with_many_rows(enum ftnode_verify_type bft, bool do_clone) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
 
@@ -636,7 +636,7 @@ test_serialize_leaf_with_many_rows(enum ftnode_verify_type bft, bool do_clone) {
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -709,10 +709,10 @@ test_serialize_leaf_with_large_rows(enum ftnode_verify_type bft, bool do_clone)
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
 
@@ -773,7 +773,7 @@ test_serialize_leaf_with_large_rows(enum ftnode_verify_type bft, bool do_clone)
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -845,10 +845,10 @@ test_serialize_leaf_with_empty_basement_nodes(enum ftnode_verify_type bft, bool
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA src_ndd = NULL;
@@ -901,7 +901,7 @@ test_serialize_leaf_with_empty_basement_nodes(enum ftnode_verify_type bft, bool
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -965,10 +965,10 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum ftnode_verify_type b
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
 
@@ -1000,7 +1000,7 @@ test_serialize_leaf_with_multiple_empty_basement_nodes(enum ftnode_verify_type b
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     toku_free(ft_h->h);
     toku_free(ft_h);
@@ -1088,10 +1088,10 @@ test_serialize_nonleaf(enum ftnode_verify_type bft, bool do_clone) {
         DISKOFF offset;
         DISKOFF size;
         toku_blocknum_realloc_on_disk(ft_h->blocktable, b, 100, &offset, ft_h, fd, false);
-        assert(offset==BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset==block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
 
         toku_translate_blocknum_to_offset_size(ft_h->blocktable, b, &offset, &size);
-        assert(offset == BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+        assert(offset == block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
         assert(size   == 100);
     }
     FTNODE_DISK_DATA src_ndd = NULL;
@@ -1123,7 +1123,7 @@ test_serialize_nonleaf(enum ftnode_verify_type bft, bool do_clone) {
     toku_ftnode_free(&dn);
     toku_destroy_ftnode_internals(&sn);
 
-    toku_block_free(ft_h->blocktable, BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
+    toku_block_free(ft_h->blocktable, block_allocator::BLOCK_ALLOCATOR_TOTAL_HEADER_RESERVE);
     toku_blocktable_destroy(&ft_h->blocktable);
     ft_h->cmp.destroy();
     toku_free(ft_h->h);

ft/tests/test_block_allocator_merge.cc

@@ -95,7 +95,7 @@ PATENT RIGHTS GRANT:
 int verbose = 0;
 
 static void
-print_array (uint64_t n, const struct block_allocator_blockpair a[/*n*/]) {
+print_array (uint64_t n, const struct block_allocator::blockpair a[/*n*/]) {
     printf("{");
     for (uint64_t i=0; i<n; i++) printf(" %016lx", (long)a[i].offset);
     printf("}\n");
@@ -103,20 +103,20 @@ print_array (uint64_t n, const struct block_allocator_blockpair a[/*n*/]) {
 
 static int
 compare_blockpairs (const void *av, const void *bv) {
-    const struct block_allocator_blockpair *CAST_FROM_VOIDP(a, av);
-    const struct block_allocator_blockpair *CAST_FROM_VOIDP(b, bv);
+    const struct block_allocator::blockpair *CAST_FROM_VOIDP(a, av);
+    const struct block_allocator::blockpair *CAST_FROM_VOIDP(b, bv);
     if (a->offset < b->offset) return -1;
     if (a->offset > b->offset) return +1;
     return 0;
 }
 
 static void
-test_merge (uint64_t an, const struct block_allocator_blockpair a[/*an*/],
-	    uint64_t bn, const struct block_allocator_blockpair b[/*bn*/]) {
+test_merge (uint64_t an, const struct block_allocator::blockpair a[/*an*/],
+	    uint64_t bn, const struct block_allocator::blockpair b[/*bn*/]) {
     if (verbose>1) { printf("a:"); print_array(an, a); }
     if (verbose>1) { printf("b:"); print_array(bn, b); }
-    struct block_allocator_blockpair *MALLOC_N(an+bn, q);
-    struct block_allocator_blockpair *MALLOC_N(an+bn, m);
+    struct block_allocator::blockpair *MALLOC_N(an+bn, q);
+    struct block_allocator::blockpair *MALLOC_N(an+bn, m);
     if (q==0 || m==0) {
 	fprintf(stderr, "malloc failed, continuing\n");
 	goto malloc_failed;
@@ -131,7 +131,7 @@ test_merge (uint64_t an, const struct block_allocator_blockpair a[/*an*/],
     qsort(q, an+bn, sizeof(*q), compare_blockpairs);
     if (verbose>1) { printf("q:"); print_array(an+bn, q); }
     if (verbose) printf("merge\n");
-    block_allocator_merge_blockpairs_into(an, m, bn, b);
+    block_allocator::merge_blockpairs_into(an, m, bn, b);
     if (verbose) printf("compare\n");
     if (verbose>1) { printf("m:"); print_array(an+bn, m); }
     for (uint64_t i=0; i<an+bn; i++) {
@@ -163,8 +163,8 @@ compute_b (uint64_t i, int mode) {
 static void
 test_merge_n_m (uint64_t n, uint64_t m, int mode)
 {
-    struct block_allocator_blockpair *MALLOC_N(n, na);
-    struct block_allocator_blockpair *MALLOC_N(m, ma);
+    struct block_allocator::blockpair *MALLOC_N(n, na);
+    struct block_allocator::blockpair *MALLOC_N(m, ma);
     if (na==0 || ma==0) {
 	fprintf(stderr, "malloc failed, continuing\n");
 	goto malloc_failed;
@@ -197,8 +197,8 @@ test_big_merge (void) {
 
 	uint64_t an = twoG;
 	uint64_t bn = 1;
-	struct block_allocator_blockpair *MALLOC_N(an+bn, a);
-        struct block_allocator_blockpair *MALLOC_N(bn,    b);
+	struct block_allocator::blockpair *MALLOC_N(an+bn, a);
+        struct block_allocator::blockpair *MALLOC_N(bn,    b);
         if (a == nullptr) {
             fprintf(stderr, "%s:%u malloc failed, continuing\n", __FUNCTION__, __LINE__);
             goto malloc_failed;
@@ -211,7 +211,7 @@ test_big_merge (void) {
         assert(b);
         for (uint64_t i=0; i<an; i++) a[i].offset=i+1;
         b[0].offset = 0;
-        block_allocator_merge_blockpairs_into(an, a, bn, b);
+        block_allocator::merge_blockpairs_into(an, a, bn, b);
         for (uint64_t i=0; i<an+bn; i++) assert(a[i].offset == i);
     malloc_failed:
         toku_free(a);

ft/tokuftdump.cc

@@ -91,11 +91,6 @@ PATENT RIGHTS GRANT:
 
 // Dump a fractal tree file
 
-#include "cachetable.h"
-#include "ft.h"
-#include "fttypes.h"
-#include "ft-internal.h"
-#include "ft/node.h"
 #include <ctype.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -103,6 +98,13 @@ PATENT RIGHTS GRANT:
 #include <inttypes.h>
 #include <limits.h>
 
+#include "ft/block_table.h"
+#include "ft/cachetable.h"
+#include "ft/ft.h"
+#include "ft/fttypes.h"
+#include "ft/ft-internal.h"
+#include "ft/node.h"
+
 static int do_dump_data = 1;
 static int do_interactive = 0;
 static int do_header = 0;