Merge branch 'merge-tokudb-5.6' into 10.0

.gitignore

@@ -166,31 +166,32 @@ storage/myisam/myisamlog
 storage/myisam/myisampack
 storage/myisam/rt_test
 storage/myisam/sp_test
-storage/tokudb/ft-index/buildheader/db.h
-storage/tokudb/ft-index/buildheader/make_tdb
-storage/tokudb/ft-index/buildheader/runcat.sh
-storage/tokudb/ft-index/ft/log_code.cc
-storage/tokudb/ft-index/ft/log_header.h
-storage/tokudb/ft-index/ft/log_print.cc
-storage/tokudb/ft-index/ft/logformat
-storage/tokudb/ft-index/ft/ftverify
-storage/tokudb/ft-index/ft/tdb-recover
-storage/tokudb/ft-index/ft/tokuftdump
-storage/tokudb/ft-index/portability/merge_archives_tokuportability_static.cmake
-storage/tokudb/ft-index/portability/toku_config.h
-storage/tokudb/ft-index/portability/tokuportability_static_depends.cc
-storage/tokudb/ft-index/src/merge_archives_tokufractaltree_static.cmake
-storage/tokudb/ft-index/src/tokufractaltree_static_depends.cc
-storage/tokudb/ft-index/toku_include/toku_config.h
-storage/tokudb/ft-index/tools/ba_replay
-storage/tokudb/ft-index/tools/ftverify
-storage/tokudb/ft-index/tools/tdb-recover
-storage/tokudb/ft-index/tools/tokudb_dump
-storage/tokudb/ft-index/tools/tokudb_gen
-storage/tokudb/ft-index/tools/tokudb_load
-storage/tokudb/ft-index/tools/tokuftdump
-storage/tokudb/ft-index/tools/tokuft_logprint
-storage/tokudb/ft-index/xz/
+storage/tokudb/PerconaFT/buildheader/db.h
+storage/tokudb/PerconaFT/buildheader/make_tdb
+storage/tokudb/PerconaFT/buildheader/runcat.sh
+storage/tokudb/PerconaFT/ft/log_code.cc
+storage/tokudb/PerconaFT/ft/log_header.h
+storage/tokudb/PerconaFT/ft/log_print.cc
+storage/tokudb/PerconaFT/ft/logformat
+storage/tokudb/PerconaFT/ft/ftverify
+storage/tokudb/PerconaFT/ft/tdb-recover
+storage/tokudb/PerconaFT/ft/tokuftdump
+storage/tokudb/PerconaFT/portability/merge_archives_tokuportability_static.cmake
+storage/tokudb/PerconaFT/portability/toku_config.h
+storage/tokudb/PerconaFT/portability/tokuportability_static_depends.cc
+storage/tokudb/PerconaFT/snappy/
+storage/tokudb/PerconaFT/src/merge_archives_tokufractaltree_static.cmake
+storage/tokudb/PerconaFT/src/tokufractaltree_static_depends.cc
+storage/tokudb/PerconaFT/toku_include/toku_config.h
+storage/tokudb/PerconaFT/tools/ba_replay
+storage/tokudb/PerconaFT/tools/ftverify
+storage/tokudb/PerconaFT/tools/tdb-recover
+storage/tokudb/PerconaFT/tools/tokudb_dump
+storage/tokudb/PerconaFT/tools/tokudb_gen
+storage/tokudb/PerconaFT/tools/tokudb_load
+storage/tokudb/PerconaFT/tools/tokuftdump
+storage/tokudb/PerconaFT/tools/tokuft_logprint
+storage/tokudb/PerconaFT/xz/
 support-files/MySQL-shared-compat.spec
 support-files/binary-configure
 support-files/config.huge.ini

storage/tokudb/CMakeLists.txt

-# ft-index only supports x86-64 and cmake-2.8.9+
+SET(TOKUDB_VERSION 5.6.26-74.0)
+# PerconaFT only supports x86-64 and cmake-2.8.9+
 IF(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND
     NOT CMAKE_VERSION VERSION_LESS "2.8.9")
 CHECK_CXX_SOURCE_COMPILES(
@@ -32,19 +33,20 @@ IF (HAVE_WVLA)
 ENDIF()
 
 ############################################
-SET(TOKUDB_VERSION "tokudb-7.5.7")
 SET(TOKUDB_DEB_FILES "usr/lib/mysql/plugin/ha_tokudb.so\netc/mysql/conf.d/tokudb.cnf\nusr/bin/tokuftdump\nusr/share/doc/mariadb-server-10.0/README-TOKUDB\nusr/share/doc/mariadb-server-10.0/README.md" PARENT_SCOPE)
-SET(USE_BDB OFF CACHE BOOL "")
 MARK_AS_ADVANCED(BUILDNAME)
 MARK_AS_ADVANCED(BUILD_TESTING)
 MARK_AS_ADVANCED(CMAKE_TOKUDB_REVISION)
 MARK_AS_ADVANCED(LIBTOKUDB)
 MARK_AS_ADVANCED(LIBTOKUPORTABILITY)
+MARK_AS_ADVANCED(PROFILING)
+MARK_AS_ADVANCED(SNAPPY_SOURCE_DIR)
 MARK_AS_ADVANCED(TOKUDB_DATA)
 MARK_AS_ADVANCED(TOKU_DEBUG_PARANOID)
-MARK_AS_ADVANCED(USE_BDB)
 MARK_AS_ADVANCED(USE_VALGRIND)
 MARK_AS_ADVANCED(XZ_SOURCE_DIR)
+MARK_AS_ADVANCED(gcc_ar)
+MARK_AS_ADVANCED(gcc_ranlib)
 ############################################
 
 SET(BUILD_TESTING OFF CACHE BOOL "")
@@ -108,14 +110,26 @@ endmacro(append_cflags_if_supported)
 set_cflags_if_supported(-Wno-missing-field-initializers)
 append_cflags_if_supported(-Wno-vla)
 
-ADD_SUBDIRECTORY(ft-index)
-
-INCLUDE_DIRECTORIES(ft-index)
-INCLUDE_DIRECTORIES(ft-index/portability)
-INCLUDE_DIRECTORIES(ft-index/util)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/ft-index)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/ft-index/buildheader)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/ft-index/portability)
+IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/PerconaFT/")
+    IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/ft-index/")
+        MESSAGE(FATAL_ERROR "Found both PerconaFT and ft-index sources.  Don't know which to use.")
+    ENDIF ()
+    SET(TOKU_FT_DIR_NAME "PerconaFT")
+    
+ELSEIF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/ft-index/")
+    MESSAGE(WARNING "Found ft-index sources, ft-index is deprecated and replaced with PerconaFT.")
+    SET(TOKU_FT_DIR_NAME "ft-index")
+ELSE ()
+        MESSAGE(FATAL_ERROR "Could not find PerconaFT sources.")
+ENDIF ()
+
+ADD_SUBDIRECTORY(${TOKU_FT_DIR_NAME})
+INCLUDE_DIRECTORIES(${TOKU_FT_DIR_NAME})
+INCLUDE_DIRECTORIES(${TOKU_FT_DIR_NAME}/portability)
+INCLUDE_DIRECTORIES(${TOKU_FT_DIR_NAME}/util)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/${TOKU_FT_DIR_NAME})
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/${TOKU_FT_DIR_NAME}/buildheader)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/${TOKU_FT_DIR_NAME}/portability)
 
 SET(TOKUDB_PLUGIN_DYNAMIC "ha_tokudb")
 SET(TOKUDB_SOURCES ha_tokudb.cc)

storage/tokudb/PerconaFT/CMakeLists.txt

+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
+
+project(TokuDB)
+
+# suppress -rdynamic
+set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "")
+set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+
+## Versions of gcc >= 4.9.0 require special version of 'ar' and 'ranlib' for
+## link-time optimizations to work properly.
+##
+## From https://gcc.gnu.org/gcc-4.9/changes.html:
+##
+##     When using a linker plugin, compiling with the -flto option now
+##     generates slim objects files (.o) which only contain intermediate
+##     language representation for LTO. Use -ffat-lto-objects to create
+##     files which contain additionally the object code. To generate
+##     static libraries suitable for LTO processing, use gcc-ar and
+##     gcc-ranlib; to list symbols from a slim object file use
+##     gcc-nm. (Requires that ar, ranlib and nm have been compiled with
+##     plugin support.)
+if ((CMAKE_CXX_COMPILER_ID STREQUAL GNU) AND
+    NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0"))
+  find_program(gcc_ar "gcc-ar")
+  if (gcc_ar)
+    set(CMAKE_AR "${gcc_ar}")
+  endif ()
+  find_program(gcc_ranlib "gcc-ranlib")
+  if (gcc_ranlib)
+    set(CMAKE_RANLIB "${gcc_ranlib}")
+  endif ()
+endif()
+
+include(TokuFeatureDetection)
+include(TokuSetupCompiler)
+include(TokuSetupCTest)
+include(TokuThirdParty)
+
+set(TOKU_CMAKE_SCRIPT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include(TokuMergeLibs)
+
+## need a way to change the name of libs we build
+set(LIBTOKUPORTABILITY "tokuportability" CACHE STRING "Name of libtokuportability.so")
+set(LIBTOKUDB "tokufractaltree" CACHE STRING "Name of libtokufractaltree.so")
+
+set(INSTALL_LIBDIR "lib" CACHE STRING "where to install libs")
+
+if (USE_VALGRIND AND NOT VALGRIND_INCLUDE_DIR MATCHES NOTFOUND)
+  include_directories(
+    ${VALGRIND_INCLUDE_DIR}
+    )
+endif()
+include_directories(
+  ${CMAKE_CURRENT_SOURCE_DIR}/portability
+  ${CMAKE_CURRENT_SOURCE_DIR}  ## so you can include <ft/ft-ops.h> from inside src/
+  ${CMAKE_CURRENT_BINARY_DIR}  ## for logging code
+  )
+## include where config.h will be generated
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/portability)
+
+## build db.h and include where it will be generated
+add_subdirectory(buildheader)
+include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/buildheader)
+
+## default includes and libraries
+include_directories(SYSTEM
+  /usr/local/include
+  ${ZLIB_INCLUDE_DIRS}
+  )
+
+## add subdirectories
+add_subdirectory(util)
+add_subdirectory(portability)
+add_subdirectory(ft)
+add_subdirectory(locktree)
+add_subdirectory(src)
+add_subdirectory(ftcxx)
+add_subdirectory(tools)
+
+INSTALL_DOCUMENTATION(README.md COPYING.AGPLv3 COPYING.GPLv2 PATENTS
+  COMPONENT Server)
+
+## build tags
+#include(TokuBuildTagDatabases)

storage/tokudb/PerconaFT/CTestCustom.cmake

+cmake_policy(SET CMP0012 NEW)
+
+## these tests shouldn't run with valgrind
+list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE
+  ft/bnc-insert-benchmark
+  ft/ft_loader-test-extractor-1
+  ft/ft_loader-test-extractor-2
+  ft/ft_loader-test-extractor-3
+  ft/upgrade_test_simple
+  portability/test-cache-line-boundary-fails
+  portability/try-leak-lost
+  portability/try-leak-reachable
+  portability/try-leak-uninit
+  util/helgrind_test_partitioned_counter
+  util/helgrind_test_partitioned_counter_5833
+  ydb/diskfull.tdb
+  ydb/drd_test_4015.tdb
+  ydb/drd_test_groupcommit_count.tdb
+  ydb/filesize.tdb
+  ydb/helgrind_helgrind1.tdb
+  ydb/helgrind_helgrind2.tdb
+  ydb/helgrind_helgrind3.tdb
+  ydb/helgrind_test_groupcommit_count.tdb
+  ydb/hot-optimize-table-tests.tdb
+  ydb/insert-dup-prelock.tdb
+  ydb/loader-cleanup-test2.tdb
+  ydb/loader-cleanup-test3.tdb
+  ydb/loader-stress-test4.tdb
+  ydb/maxsize-for-loader-B.tdb
+  ydb/openlimit17.tdb
+  ydb/openlimit17-locktree.tdb
+  ydb/preload-db-nested.tdb
+  ydb/stress-gc.tdb
+  ydb/stress-gc2.tdb
+  ydb/stress-test.tdb
+  ydb/test-5138.tdb
+  ydb/test-prepare.tdb
+  ydb/test-prepare2.tdb
+  ydb/test-prepare3.tdb
+  ydb/test-recover1.tdb
+  ydb/test-recover2.tdb
+  ydb/test-recover3.tdb
+  ydb/test-xa-prepare.tdb
+  ydb/test4573-logtrim.tdb
+  ydb/test_3645.tdb
+  ydb/test_groupcommit_perf.tdb
+  ydb/test_large_update_broadcast_small_cachetable.tdb
+  ydb/test_update_broadcast_stress.tdb
+  ydb/test_update_stress.tdb
+  ydb/upgrade-test-4.tdb
+  )
+
+if (NOT @RUN_HELGRIND_TESTS@)
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE
+    util/helgrind_test_partitioned_counter
+    util/helgrind_test_partitioned_counter_5833
+    ydb/helgrind_helgrind1.tdb
+    ydb/helgrind_helgrind2.tdb
+    ydb/helgrind_helgrind3.tdb
+    ydb/helgrind_test_groupcommit_count.tdb
+    )
+endif ()
+
+if (NOT @RUN_DRD_TESTS@)
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE
+    ydb/drd_test_groupcommit_count.tdb
+    ydb/drd_test_4015.tdb
+    )
+endif ()
+
+## osx's pthreads prefer writers, so this test will deadlock
+if (@CMAKE_SYSTEM_NAME@ STREQUAL Darwin)
+  list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE portability/test-pthread-rwlock-rwr)
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE portability/test-pthread-rwlock-rwr)
+endif ()
+
+## tests that are supposed to crash will generate memcheck failures
+set(tests_that_should_fail
+  ft/test-assertA
+  ft/test-assertB
+  portability/try-assert-zero
+  portability/try-assert0
+  ydb/recover-missing-dbfile-2.abortrecover
+  ydb/recover-missing-dbfile.abortrecover
+  ydb/test_db_no_env.tdb
+  ydb/test_truncate_txn_abort.tdb
+  )
+list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${tests_that_should_fail})
+
+## don't run drd stress tests with valgrind either (because that would do valgrind twice)
+set(stress_tests
+  test_stress0.tdb
+  test_stress1.tdb
+  test_stress2.tdb
+  test_stress3.tdb
+  test_stress4.tdb
+  test_stress5.tdb
+  test_stress6.tdb
+  test_stress7.tdb
+  test_stress_hot_indexing.tdb
+  test_stress_openclose.tdb
+  test_stress_with_verify.tdb
+  )
+foreach(test ${stress_tests})
+  list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE
+    ydb/drd_tiny_${test}
+    ydb/drd_mid_${test}
+    ydb/drd_large_${test}
+    )
+  if(NOT @RUN_LONG_TESTS@)
+    list(APPEND CTEST_CUSTOM_TESTS_IGNORE
+      ydb/drd_large_${test}
+      )
+  endif()
+  if (NOT @RUN_DRD_TESTS@)
+    list(APPEND CTEST_CUSTOM_TESTS_IGNORE
+      ydb/drd_tiny_${test}
+      ydb/drd_mid_${test}
+      ydb/drd_large_${test}
+      )
+  endif ()
+endforeach(test)
+
+## upgrade stress tests are 5 minutes long, don't need to run them always
+if(NOT @RUN_LONG_TESTS@)
+  foreach(test ${stress_tests})
+    if (NOT ${test} MATCHES test_stress_openclose)
+      foreach(oldver 4.2.0 5.0.8 5.2.7 6.0.0 6.1.0 6.5.1 6.6.3)
+        foreach(p_or_s pristine stressed)
+          if (NOT (${test} MATCHES test_stress4 AND ${p_or_s} MATCHES stressed))
+            foreach(size 2000)
+              list(APPEND CTEST_CUSTOM_TESTS_IGNORE ydb/${test}/upgrade/${oldver}/${p_or_s}/${size})
+            endforeach(size)
+          endif ()
+        endforeach(p_or_s)
+      endforeach(oldver)
+    endif ()
+  endforeach(test)
+endif()
+
+set(tdb_tests_that_should_fail "ydb/${stress_tests}")
+string(REGEX REPLACE ";" ";ydb/" stress_tests "${stress_tests}")
+
+set(recover_stress_tests
+  ydb/recover-test_stress1.abortrecover
+  ydb/recover-test_stress2.abortrecover
+  ydb/recover-test_stress3.abortrecover
+  ydb/recover-test_stress_openclose.abortrecover
+  )
+
+## we run stress tests separately, only run them if asked to
+if(NOT @RUN_STRESS_TESTS@)
+  list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${stress_tests} ${recover_stress_tests})
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE ${stress_tests} ${recover_stress_tests})
+endif()
+
+set(perf_tests
+  ydb/perf_checkpoint_var.tdb
+  ydb/perf_cursor_nop.tdb
+  ydb/perf_malloc_free.tdb
+  ydb/perf_nop.tdb
+  ydb/perf_ptquery.tdb
+  ydb/perf_ptquery2.tdb
+  ydb/perf_read_write.tdb
+  ydb/perf_xmalloc_free.tdb
+  )
+
+## we also don't need to run perf tests every time
+if(NOT @RUN_PERF_TESTS@)
+  list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${perf_tests})
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE ${perf_tests})
+endif()
+
+## don't run perf tests with valgrind (that's slow)
+file(GLOB perf_test_srcs RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/src/tests" perf_*.cc)
+string(REGEX REPLACE "\\.cc(;|$)" ".tdb\\1" perf_tests "${perf_test_srcs}")
+set(tdb_tests_that_should_fail "ydb/${perf_tests}")
+string(REGEX REPLACE ";" ";ydb/" perf_tests "${perf_tests}")
+list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${perf_tests})
+
+## these tests fail often and aren't helpful
+set(known_failing_tests
+  ydb/diskfull.tdb
+  )
+list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${known_failing_tests})
+list(APPEND CTEST_CUSTOM_TESTS_IGNORE ${known_failing_tests})
+
+## these tests take a long time, only run them if asked to
+set(long_running_tests
+  ft/is_empty
+  ft/upgrade_test_simple
+  ydb/checkpoint_1.tdb
+  ydb/checkpoint_stress.tdb
+  ydb/hotindexer-with-queries.tdb
+  ydb/hot-optimize-table-tests.tdb
+  ydb/loader-cleanup-test0.tdb
+  ydb/loader-cleanup-test0z.tdb
+  ydb/loader-cleanup-test2.tdb
+  ydb/loader-cleanup-test2z.tdb
+  ydb/loader-stress-test4.tdb
+  ydb/loader-stress-test4z.tdb
+  ydb/manyfiles.tdb
+  ydb/preload-db-nested.tdb
+  ydb/recover_stress.tdb
+  ydb/root_fifo_1.tdb
+  ydb/root_fifo_2.tdb
+  ydb/root_fifo_31.tdb
+  ydb/root_fifo_32.tdb
+  ydb/stress-gc.tdb
+  ydb/stress-test.tdb
+  ydb/test3529.tdb
+  ydb/test_logmax.tdb
+  ydb/test_txn_nested2.tdb
+  ydb/test_update_broadcast_stress.tdb
+  ydb/test_update_stress.tdb
+  )
+if(NOT @RUN_LONG_TESTS@)
+  list(APPEND CTEST_CUSTOM_MEMCHECK_IGNORE ${long_running_tests})
+  list(APPEND CTEST_CUSTOM_TESTS_IGNORE ${long_running_tests})
+endif()
+
+## ignore log_print.cc in coverage report
+list(APPEND CTEST_CUSTOM_COVERAGE_EXCLUDE "log_print.cc")
+
+list(APPEND CTEST_CUSTOM_WARNING_EXCEPTION
+  # don't complain about warnings in xz source
+  "xz-4.999.9beta/src/liblzma"
+  # don't complain about clang missing warnings from xz code
+  "clang: warning: unknown warning option"
+  # don't complain about warnings in jemalloc source
+  "jemalloc/src"
+  "jemalloc/internal"
+  # don't complain about valgrind headers leaving things unused
+  "valgrind/valgrind.h"
+  "valgrind/memcheck.h"
+  # don't complain about ranlib or libtool on empty archive
+  "has no symbols"
+  "the table of contents is empty"
+  )

storage/tokudb/PerconaFT/PATENTS

+UNIVERSITY PATENT NOTICE:
+  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.
+PATENT MARKING NOTICE:
+  This software is covered by US Patent No. 8,185,551.
+  This software is covered by US Patent No. 8,489,638.
+PATENT RIGHTS GRANT:
+  "THIS IMPLEMENTATION" means the copyrightable works distributed by
+  Percona as part of the Fractal Tree project.
+  "PATENT CLAIMS" means the claims of patents that are owned or
+  licensable by Percona, both currently or in the future; and that in
+  the absence of this license would be infringed by THIS
+  IMPLEMENTATION or by using or running THIS IMPLEMENTATION.
+  "PATENT CHALLENGE" shall mean a challenge to the validity,
+  patentability, enforceability and/or non-infringement of any of the
+  PATENT CLAIMS or otherwise opposing any of the PATENT CLAIMS.
+  Percona hereby grants to you, for the term and geographical scope of
+  the PATENT CLAIMS, a non-exclusive, no-charge, royalty-free,
+  irrevocable (except as stated in this section) patent license to
+  make, have made, use, offer to sell, sell, import, transfer, and
+  otherwise run, modify, and propagate the contents of THIS
+  IMPLEMENTATION, where such license applies only to the PATENT
+  CLAIMS.  This grant does not include claims that would be infringed
+  only as a consequence of further modifications of THIS
+  IMPLEMENTATION.  If you or your agent or licensee institute or order
+  or agree to the institution of patent litigation against any entity
+  (including a cross-claim or counterclaim in a lawsuit) alleging that
+  THIS IMPLEMENTATION constitutes direct or contributory patent
+  infringement, or inducement of patent infringement, then any rights
+  granted to you under this License shall terminate as of the date
+  such litigation is filed.  If you or your agent or exclusive
+  licensee institute or order or agree to the institution of a PATENT
+  CHALLENGE, then Percona may terminate any rights granted to you
+  under this License.

storage/tokudb/PerconaFT/README.md

+PerconaFT
+======
+
+PerconaFT is a high-performance, transactional key-value store, used in the
+TokuDB storage engine for Percona Server and MySQL, and in TokuMX, the
+high-performance MongoDB distribution.
+
+PerconaFT is provided as a shared library with an interface similar to
+Berkeley DB.
+
+To build the full MySQL product, see the instructions for
+[Percona/tokudb-engine][tokudb-engine].  To build TokuMX, see the instructions
+for [Percona/percona-server-mongodb][mongo].  This document covers PerconaFT only.
+
+[tokudb-engine]: https://github.com/Percona/tokudb-engine
+[mongo]: https://github.com/Percona/percona-server-mongodb
+
+
+Building
+--------
+
+PerconaFT is built using CMake >= 2.8.9.  Out-of-source builds are
+recommended.  You need a C++11 compiler, though only GCC >= 4.7 and
+Apple's Clang are tested.  You also need zlib development packages
+(`yum install zlib-devel` or `apt-get install zlib1g-dev`).
+
+You will also need the source code for jemalloc, checked out in
+`third_party/`.
+
+```sh
+git clone git://github.com/Percona/PerconaFT.git percona-ft
+cd percona-ft
+git clone git://github.com/Percona/jemalloc.git third_party/jemalloc
+mkdir build
+cd build
+CC=gcc47 CXX=g++47 cmake \
+    -D CMAKE_BUILD_TYPE=Debug \
+    -D BUILD_TESTING=OFF \
+    -D USE_VALGRIND=OFF \
+    -D CMAKE_INSTALL_PREFIX=../prefix/ \
+    ..
+cmake --build . --target install
+```
+
+This will build `libtokudb.so` and `libtokuportability.so` and install it,
+some header files, and some examples to `percona-ft/prefix/`.  It will also
+build jemalloc and install it alongside these libraries, you should link
+to that if you are planning to run benchmarks or in production.
+
+### Platforms
+
+PerconaFT is supported on 64-bit Centos, should work on other 64-bit linux
+distributions, and may work on OSX 10.8 and FreeBSD.  PerconaFT is not
+supported on 32-bit systems.
+
+[Transparent hugepages][transparent-hugepages] is a feature in newer linux
+kernel versions that causes problems for the memory usage tracking
+calculations in PerconaFT and can lead to memory overcommit.  If you have
+this feature enabled, PerconaFT will not start, and you should turn it off.
+If you want to run with transparent hugepages on, you can set an
+environment variable `TOKU_HUGE_PAGES_OK=1`, but only do this for testing,
+and only with a small cache size.
+
+[transparent-hugepages]: https://access.redhat.com/site/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Performance_Tuning_Guide/s-memory-transhuge.html
+
+
+Testing
+-------
+
+PerconaFT uses CTest for testing.  The CDash testing dashboard is not
+currently public, but you can run the tests without submitting them.
+
+There are some large data files not stored in the git repository, that
+will be made available soon.  For now, the tests that use these files will
+not run.
+
+In the build directory from above:
+
+```sh
+cmake -D BUILD_TESTING=ON ..
+ctest -D ExperimentalStart \
+      -D ExperimentalConfigure \
+      -D ExperimentalBuild \
+      -D ExperimentalTest
+```
+
+
+Contributing
+------------
+
+Please report bugs in PerconaFT to the [issue tracker][jira].
+
+We have two publicly accessible mailing lists for TokuDB:
+
+ - tokudb-user@googlegroups.com is for general and support related
+   questions about the use of TokuDB.
+ - tokudb-dev@googlegroups.com is for discussion of the development of
+   TokuDB.
+
+and two for TokuMX:
+
+ - tokumx-user@googlegroups.com is for general and support related
+   questions about the use of TokuMX.
+ - tokumx-dev@googlegroups.com is for discussion of the development of
+   TokuMX.
+
+All source code and test contributions must be provided under a [BSD 2-Clause][bsd-2] license. For any small change set, the license text may be contained within the commit comment and the pull request. For larger contributions, the license must be presented in a COPYING.<feature_name> file in the root of the PerconaFT project. Please see the [BSD 2-Clause license template][bsd-2] for the content of the license text.
+
+[jira]: https://tokutek.atlassian.net/browse/FT/
+[bsd-2]: http://opensource.org/licenses/BSD-2-Clause/
+
+
+License
+-------
+
+PerconaFT is available under the GPL version 2, and AGPL version 3, with slight modifications.
+See [COPYING.AGPLv3][agpllicense],
+[COPYING.GPLv2][gpllicense], and
+[PATENTS][patents].
+
+[agpllicense]: http://github.com/Perona/PerconaFT/blob/master/COPYING.AGPLv3
+[gpllicense]: http://github.com/Perona/PerconaFT/blob/master/COPYING.GPLv2
+[patents]: http://github.com/Perona/PerconaFT/blob/master/PATENTS

storage/tokudb/PerconaFT/buildheader/CMakeLists.txt

+set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES "")
+
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/runcat.sh" "#!/bin/bash
+out=$1; shift
+exec \"$@\" >$out")
+
+add_executable(make_tdb make_tdb.cc)
+set_property(TARGET make_tdb APPEND PROPERTY COMPILE_DEFINITIONS _GNU_SOURCE)
+add_custom_command(
+  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/db.h"
+  COMMAND bash runcat.sh "${CMAKE_CURRENT_BINARY_DIR}/db.h" $<TARGET_FILE:make_tdb>
+  DEPENDS make_tdb)
+add_custom_target(install_tdb_h DEPENDS
+  "${CMAKE_CURRENT_BINARY_DIR}/db.h")
+
+# detect when we are being built as a subproject
+if (NOT DEFINED MYSQL_PROJECT_NAME_DOCSTRING)
+  install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/db.h"
+    DESTINATION include
+    RENAME tokudb.h
+    COMPONENT tokukv_headers
+    )
+  install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/db.h"
+    DESTINATION include
+    COMPONENT tokukv_headers
+    )
+endif ()

storage/tokudb/PerconaFT/cmake_modules/TokuBuildTagDatabases.cmake

+## set up lists of sources and headers for tags
+file(GLOB_RECURSE all_srcs
+  buildheader/*.cc
+  db-benchmark-test/*.cc
+  ft/*.cc
+  include/*.cc
+  locktree/*.cc
+  portability/*.cc
+  src/*.cc
+  utils/*.cc
+  util/*.cc
+  db-benchmark-test/*.cc
+  )
+list(APPEND all_srcs
+  ${CMAKE_CURRENT_BINARY_DIR}/ft/log_code.cc
+  ${CMAKE_CURRENT_BINARY_DIR}/ft/log_print.cc
+  )
+file(GLOB_RECURSE all_hdrs
+  buildheader/*.h
+  db-benchmark-test/*.h
+  ft/*.h
+  include/*.h
+  locktree/*.h
+  portability/*.h
+  src/*.h
+  utils/*.h
+  util/*.h
+  db-benchmark-test/*.h
+  )
+list(APPEND all_hdrs
+  ${CMAKE_CURRENT_BINARY_DIR}/portability/toku_config.h
+  ${CMAKE_CURRENT_BINARY_DIR}/buildheader/db.h
+  ${CMAKE_CURRENT_BINARY_DIR}/ft/log_header.h
+  )
+
+option(USE_ETAGS "Build the etags database." ON)
+if (USE_ETAGS)
+  find_program(ETAGS "etags")
+  if (NOT ETAGS MATCHES NOTFOUND)
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/TAGS"
+      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/etags-stamp"
+      COMMAND ${ETAGS} -o TAGS ${all_srcs} ${all_hdrs}
+      COMMAND touch "${CMAKE_CURRENT_BINARY_DIR}/etags-stamp"
+      DEPENDS ${all_srcs} ${all_hdrs} install_tdb_h generate_config_h generate_log_code
+      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    add_custom_target(build_etags ALL DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/TAGS" etags-stamp)
+  endif ()
+endif ()
+
+option(USE_CTAGS "Build the ctags database." ON)
+if (USE_CTAGS AND
+    # Macs by default are not case-sensitive, so tags and TAGS clobber each other.  Do etags and not ctags in that case, because Emacs is superior. :P
+    (NOT APPLE OR NOT USE_ETAGS))
+  find_program(CTAGS "ctags")
+  if (NOT CTAGS MATCHES NOTFOUND)
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/tags"
+      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/ctags-stamp"
+      COMMAND ${CTAGS} -o tags ${all_srcs} ${all_hdrs}
+      COMMAND touch "${CMAKE_CURRENT_BINARY_DIR}/ctags-stamp"
+      DEPENDS ${all_srcs} ${all_hdrs} install_tdb_h generate_config_h generate_log_code
+      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    add_custom_target(build_ctags ALL DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/tags" ctags-stamp)
+  endif ()
+endif ()
+
+option(USE_CSCOPE "Build the cscope database." ON)
+if (USE_CSCOPE)
+  find_program(CSCOPE "cscope")
+  if (NOT CSCOPE MATCHES NOTFOUND)
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cscope.files" "")
+    foreach(file ${all_srcs} ${all_hdrs})
+      file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/cscope.files" "${file}\n")
+    endforeach(file)
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/cscope.out"
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/cscope.in.out"
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/cscope.po.out"
+      COMMAND ${CSCOPE} -b -q -R -i"${CMAKE_CURRENT_BINARY_DIR}/cscope.files" -I"${CMAKE_CURRENT_SOURCE_DIR}" -I"${CMAKE_CURRENT_SOURCE_DIR}/include" -I"${CMAKE_CURRENT_SOURCE_DIR}/portability" -I"${CMAKE_CURRENT_SOURCE_DIR}/portability" -I"${CMAKE_CURRENT_SOURCE_DIR}/ft" -I"${CMAKE_CURRENT_SOURCE_DIR}/src" -I"${CMAKE_CURRENT_SOURCE_DIR}/locktree" -I"${CMAKE_CURRENT_SOURCE_DIR}/utils" -I"${CMAKE_CURRENT_SOURCE_DIR}/db-benchmark-test" -I"${CMAKE_CURRENT_BINARY_DIR}" -I"${CMAKE_CURRENT_BINARY_DIR}/portability" -I"${CMAKE_CURRENT_BINARY_DIR}/buildheader"
+      DEPENDS ${all_srcs} ${all_hdrs} install_tdb_h generate_config_h generate_log_code
+      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    add_custom_target(build_cscope.out ALL DEPENDS
+      "${CMAKE_CURRENT_SOURCE_DIR}/cscope.out"
+      "${CMAKE_CURRENT_SOURCE_DIR}/cscope.in.out"
+      "${CMAKE_CURRENT_SOURCE_DIR}/cscope.po.out")
+  endif ()
+endif ()
+
+option(USE_GTAGS "Build the gtags database." ON)
+if (USE_GTAGS)
+  find_program(GTAGS "gtags")
+  if (NOT GTAGS MATCHES NOTFOUND)
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/gtags.files" "")
+    foreach(file ${all_srcs} ${all_hdrs})
+      file(APPEND "${CMAKE_CURRENT_BINARY_DIR}/gtags.files" "${file}\n")
+    endforeach(file)
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/GTAGS"
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/GRTAGS"
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/GPATH"
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/GSYMS"
+      COMMAND ${GTAGS} -f "${CMAKE_CURRENT_BINARY_DIR}/gtags.files"
+      DEPENDS ${all_srcs} ${all_hdrs} install_tdb_h generate_config_h generate_log_code
+      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    add_custom_target(build_GTAGS ALL DEPENDS
+      "${CMAKE_CURRENT_SOURCE_DIR}/GTAGS"
+      "${CMAKE_CURRENT_SOURCE_DIR}/GRTAGS"
+      "${CMAKE_CURRENT_SOURCE_DIR}/GPATH"
+      "${CMAKE_CURRENT_SOURCE_DIR}/GSYMS")
+  endif ()
+endif ()
+
+option(USE_MKID "Build the idutils database." ON)
+if (USE_MKID)
+  find_program(MKID "mkid")
+  if (NOT MKID MATCHES NOTFOUND)
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/ID"
+      COMMAND ${MKID} ${all_srcs} ${all_hdrs}
+      DEPENDS ${all_srcs} ${all_hdrs} install_tdb_h generate_config_h generate_log_code
+      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    add_custom_target(build_MKID ALL DEPENDS
+      "${CMAKE_CURRENT_SOURCE_DIR}/ID")
+  endif ()
+endif ()

storage/tokudb/PerconaFT/cmake_modules/TokuFeatureDetection.cmake

+## feature detection
+find_package(Threads)
+find_package(ZLIB REQUIRED)
+
+option(USE_VALGRIND "Build to run safely under valgrind (often slower)." ON)
+if(USE_VALGRIND)
+  find_package(Valgrind REQUIRED)
+endif()
+
+option(TOKU_DEBUG_PARANOID "Enable paranoid asserts." ON)
+
+include(CheckIncludeFiles)
+
+## check for some include files
+check_include_files(alloca.h HAVE_ALLOCA_H)
+check_include_files(arpa/inet.h HAVE_ARPA_INET_H)
+check_include_files(bits/functexcept.h HAVE_BITS_FUNCTEXCEPT_H)
+check_include_files(byteswap.h HAVE_BYTESWAP_H)
+check_include_files(endian.h HAVE_ENDIAN_H)
+check_include_files(fcntl.h HAVE_FCNTL_H)
+check_include_files(inttypes.h HAVE_INTTYPES_H)
+check_include_files(libkern/OSAtomic.h HAVE_LIBKERN_OSATOMIC_H)
+check_include_files(libkern/OSByteOrder.h HAVE_LIBKERN_OSBYTEORDER_H)
+check_include_files(limits.h HAVE_LIMITS_H)
+check_include_files(machine/endian.h HAVE_MACHINE_ENDIAN_H)
+check_include_files(malloc.h HAVE_MALLOC_H)
+check_include_files(malloc/malloc.h HAVE_MALLOC_MALLOC_H)
+check_include_files(malloc_np.h HAVE_MALLOC_NP_H)
+check_include_files(pthread.h HAVE_PTHREAD_H)
+check_include_files(pthread_np.h HAVE_PTHREAD_NP_H)
+check_include_files(stdint.h HAVE_STDINT_H)
+check_include_files(stdlib.h HAVE_STDLIB_H)
+check_include_files(string.h HAVE_STRING_H)
+check_include_files(syscall.h HAVE_SYSCALL_H)
+check_include_files(sys/endian.h HAVE_SYS_ENDIAN_H)
+check_include_files(sys/file.h HAVE_SYS_FILE_H)
+check_include_files(sys/malloc.h HAVE_SYS_MALLOC_H)
+check_include_files(sys/prctl.h HAVE_SYS_PRCTL_H)
+check_include_files(sys/resource.h HAVE_SYS_RESOURCE_H)
+check_include_files(sys/statvfs.h HAVE_SYS_STATVFS_H)
+check_include_files(sys/syscall.h HAVE_SYS_SYSCALL_H)
+check_include_files(sys/sysctl.h HAVE_SYS_SYSCTL_H)
+check_include_files(sys/syslimits.h HAVE_SYS_SYSLIMITS_H)
+check_include_files(sys/time.h HAVE_SYS_TIME_H)
+check_include_files(unistd.h HAVE_UNISTD_H)
+
+include(CheckSymbolExists)
+
+## check whether we can set the mmap threshold like we can in gnu libc's malloc
+check_symbol_exists(M_MMAP_THRESHOLD "malloc.h" HAVE_M_MMAP_THRESHOLD)
+## check whether we have CLOCK_REALTIME
+check_symbol_exists(CLOCK_REALTIME "time.h" HAVE_CLOCK_REALTIME)
+## check how to do direct I/O
+if (NOT CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+  set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
+endif ()
+check_symbol_exists(O_DIRECT "fcntl.h" HAVE_O_DIRECT)
+check_symbol_exists(F_NOCACHE "fcntl.h" HAVE_F_NOCACHE)
+check_symbol_exists(MAP_ANONYMOUS "sys/mman.h" HAVE_MAP_ANONYMOUS)
+check_symbol_exists(PR_SET_PTRACER "sys/prctl.h" HAVE_PR_SET_PTRACER)
+check_symbol_exists(PR_SET_PTRACER_ANY "sys/prctl.h" HAVE_PR_SET_PTRACER_ANY)
+
+include(CheckFunctionExists)
+
+## check for the right way to get the actual allocation size of a pointer
+check_function_exists(malloc_size HAVE_MALLOC_SIZE)
+check_function_exists(malloc_usable_size HAVE_MALLOC_USABLE_SIZE)
+## check whether we have memalign or valloc (a weak substitute for memalign on darwin)
+check_function_exists(memalign HAVE_MEMALIGN)
+check_function_exists(valloc HAVE_VALLOC)
+## check whether we have random_r or nrand48 to use as a reentrant random function
+check_function_exists(nrand48 HAVE_NRAND48)
+check_function_exists(random_r HAVE_RANDOM_R)
+check_function_exists(mincore HAVE_MINCORE)
+
+## clear this out in case mysql modified it
+set(CMAKE_REQUIRED_LIBRARIES "")
+set(EXTRA_SYSTEM_LIBS "")
+check_function_exists(dlsym HAVE_DLSYM_WITHOUT_DL)
+if (NOT HAVE_DLSYM_WITHOUT_DL)
+  set(CMAKE_REQUIRED_LIBRARIES dl)
+  check_function_exists(dlsym HAVE_DLSYM_WITH_DL)
+  if (HAVE_DLSYM_WITH_DL)
+    list(APPEND EXTRA_SYSTEM_LIBS dl)
+  else ()
+    message(FATAL_ERROR "Cannot find dlsym(), even with -ldl.")
+  endif ()
+endif ()
+check_function_exists(backtrace HAVE_BACKTRACE_WITHOUT_EXECINFO)
+if (NOT HAVE_BACKTRACE_WITHOUT_EXECINFO)
+  set(CMAKE_REQUIRED_LIBRARIES execinfo)
+  check_function_exists(backtrace HAVE_BACKTRACE_WITH_EXECINFO)
+  if (HAVE_BACKTRACE_WITH_EXECINFO)
+    list(APPEND EXTRA_SYSTEM_LIBS execinfo)
+  else ()
+    message(FATAL_ERROR "Cannot find backtrace(), even with -lexecinfo.")
+  endif ()
+endif ()
+
+if(HAVE_CLOCK_REALTIME)
+  list(APPEND EXTRA_SYSTEM_LIBS rt)
+else()
+  list(APPEND EXTRA_SYSTEM_LIBS System)
+endif()
+
+set(CMAKE_REQUIRED_LIBRARIES pthread)
+## check whether we can change rwlock preference
+check_function_exists(pthread_rwlockattr_setkind_np HAVE_PTHREAD_RWLOCKATTR_SETKIND_NP)
+## check for the right way to yield using pthreads
+check_function_exists(pthread_yield HAVE_PTHREAD_YIELD)
+check_function_exists(pthread_yield_np HAVE_PTHREAD_YIELD_NP)
+## check if we have pthread_getthreadid_np() (i.e. freebsd)
+check_function_exists(pthread_getthreadid_np HAVE_PTHREAD_GETTHREADID_NP)
+check_function_exists(sched_getcpu HAVE_SCHED_GETCPU)
+
+include(CheckCSourceCompiles)
+
+if (HAVE_PTHREAD_YIELD)
+  include(CheckPrototypeDefinition)
+
+  check_prototype_definition(pthread_yield "void pthread_yield(void)" "(void)0" "pthread.h" PTHREAD_YIELD_RETURNS_VOID)
+  check_c_source_compiles("#include <pthread.h>
+int main(void) {
+  int r = pthread_yield();
+  return r;
+}" PTHREAD_YIELD_RETURNS_INT)
+endif (HAVE_PTHREAD_YIELD)
+
+## check whether we have gcc-style thread-local storage using a storage class modifier
+check_c_source_compiles("#include <pthread.h>
+static __thread int tlsvar = 0;
+int main(void) { return tlsvar; }" HAVE_GNU_TLS)
+
+## set TOKUDB_REVISION
+set(CMAKE_TOKUDB_REVISION 0 CACHE INTEGER "Revision of tokudb.")

storage/tokudb/PerconaFT/cmake_modules/TokuSetupCompiler.cmake

+function(add_c_defines)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS ${ARGN})
+endfunction(add_c_defines)
+
+if (APPLE)
+  add_c_defines(DARWIN=1 _DARWIN_C_SOURCE)
+endif ()
+
+## preprocessor definitions we want everywhere
+add_c_defines(
+  _FILE_OFFSET_BITS=64
+  _LARGEFILE64_SOURCE
+  __STDC_FORMAT_MACROS
+  __STDC_LIMIT_MACROS
+  __LONG_LONG_SUPPORTED
+  )
+if (NOT CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+  ## on FreeBSD these types of macros actually remove functionality
+  add_c_defines(
+    _DEFAULT_SOURCE
+    _XOPEN_SOURCE=600
+    )
+endif ()
+
+## add TOKU_PTHREAD_DEBUG for debug builds
+if (CMAKE_VERSION VERSION_LESS 3.0)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG TOKU_PTHREAD_DEBUG=1)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DRD TOKU_PTHREAD_DEBUG=1)
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DRD _FORTIFY_SOURCE=2)
+else ()
+  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS
+    $<$<OR:$<CONFIG:DEBUG>,$<CONFIG:DRD>>:TOKU_PTHREAD_DEBUG=1>
+    $<$<CONFIG:DRD>:_FORTIFY_SOURCE=2>
+    )
+endif ()
+
+## coverage
+option(USE_GCOV "Use gcov for test coverage." OFF)
+if (USE_GCOV)
+  if (NOT CMAKE_CXX_COMPILER_ID MATCHES GNU)
+    message(FATAL_ERROR "Must use the GNU compiler to compile for test coverage.")
+  endif ()
+  find_program(COVERAGE_COMMAND NAMES gcov47 gcov)
+endif (USE_GCOV)
+
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+
+## adds a compiler flag if the compiler supports it
+macro(set_cflags_if_supported_named flag flagname)
+  check_c_compiler_flag("${flag}" HAVE_C_${flagname})
+  if (HAVE_C_${flagname})
+    set(CMAKE_C_FLAGS "${flag} ${CMAKE_C_FLAGS}")
+  endif ()
+  check_cxx_compiler_flag("${flag}" HAVE_CXX_${flagname})
+  if (HAVE_CXX_${flagname})
+    set(CMAKE_CXX_FLAGS "${flag} ${CMAKE_CXX_FLAGS}")
+  endif ()
+endmacro(set_cflags_if_supported_named)
+
+## adds a compiler flag if the compiler supports it
+macro(set_cflags_if_supported)
+  foreach(flag ${ARGN})
+    check_c_compiler_flag(${flag} HAVE_C_${flag})
+    if (HAVE_C_${flag})
+      set(CMAKE_C_FLAGS "${flag} ${CMAKE_C_FLAGS}")
+    endif ()
+    check_cxx_compiler_flag(${flag} HAVE_CXX_${flag})
+    if (HAVE_CXX_${flag})
+      set(CMAKE_CXX_FLAGS "${flag} ${CMAKE_CXX_FLAGS}")
+    endif ()
+  endforeach(flag)
+endmacro(set_cflags_if_supported)
+
+## adds a linker flag if the compiler supports it
+macro(set_ldflags_if_supported)
+  foreach(flag ${ARGN})
+    check_cxx_compiler_flag(${flag} HAVE_${flag})
+    if (HAVE_${flag})
+      set(CMAKE_EXE_LINKER_FLAGS "${flag} ${CMAKE_EXE_LINKER_FLAGS}")
+      set(CMAKE_SHARED_LINKER_FLAGS "${flag} ${CMAKE_SHARED_LINKER_FLAGS}")
+    endif ()
+  endforeach(flag)
+endmacro(set_ldflags_if_supported)
+
+## disable some warnings
+set_cflags_if_supported(
+  -Wno-missing-field-initializers
+  -Wstrict-null-sentinel
+  -Winit-self
+  -Wswitch
+  -Wtrampolines
+  -Wlogical-op
+  -Wmissing-format-attribute
+  -Wno-error=missing-format-attribute
+  -Wno-error=address-of-array-temporary
+  -Wno-error=tautological-constant-out-of-range-compare
+  -Wno-ignored-attributes
+  -Wno-error=extern-c-compat
+  -fno-rtti
+  -fno-exceptions
+  )
+## set_cflags_if_supported_named("-Weffc++" -Weffcpp)
+
+if (CMAKE_CXX_FLAGS MATCHES -fno-implicit-templates)
+  # must append this because mysql sets -fno-implicit-templates and we need to override it
+  check_cxx_compiler_flag(-fimplicit-templates HAVE_CXX_-fimplicit-templates)
+  if (HAVE_CXX_-fimplicit-templates)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fimplicit-templates")
+  endif ()
+endif()
+
+## Clang has stricter POD checks.  So, only enable this warning on our other builds (Linux + GCC)
+if (NOT CMAKE_CXX_COMPILER_ID MATCHES Clang)
+  set_cflags_if_supported(
+    -Wpacked
+    )
+endif ()
+
+option (PROFILING "Allow profiling and debug" ON)
+if (PROFILING)
+  set_cflags_if_supported(
+    -fno-omit-frame-pointer
+  )
+endif ()
+
+## this hits with optimized builds somewhere in ftleaf_split, we don't
+## know why but we don't think it's a big deal
+set_cflags_if_supported(
+  -Wno-error=strict-overflow
+  )
+set_ldflags_if_supported(
+  -Wno-error=strict-overflow
+  )
+
+## set extra debugging flags and preprocessor definitions
+set(CMAKE_C_FLAGS_DEBUG "-g3 -O0 ${CMAKE_C_FLAGS_DEBUG}")
+set(CMAKE_CXX_FLAGS_DEBUG "-g3 -O0 ${CMAKE_CXX_FLAGS_DEBUG}")
+
+## flags to use when we want to run DRD on the resulting binaries
+## DRD needs debugging symbols.
+## -O0 makes it too slow, and -O2 inlines too much for our suppressions to work.  -O1 is just right.
+set(CMAKE_C_FLAGS_DRD "-g3 -O1 ${CMAKE_C_FLAGS_DRD}")
+set(CMAKE_CXX_FLAGS_DRD "-g3 -O1 ${CMAKE_CXX_FLAGS_DRD}")
+
+## set extra release flags
+## need to set flags for RelWithDebInfo as well because we want the MySQL/MariaDB builds to use them
+if (CMAKE_CXX_COMPILER_ID STREQUAL Clang)
+  # have tried -flto and -O4, both make our statically linked executables break apple's linker
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -g -O3 -UNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -g -O3 -UNDEBUG")
+  set(CMAKE_C_FLAGS_RELEASE "-g -O3 ${CMAKE_C_FLAGS_RELEASE} -UNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELEASE "-g -O3 ${CMAKE_CXX_FLAGS_RELEASE} -UNDEBUG")
+else ()
+  # we overwrite this because the default passes -DNDEBUG and we don't want that
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-flto -fuse-linker-plugin ${CMAKE_C_FLAGS_RELWITHDEBINFO} -g -O3 -UNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-flto -fuse-linker-plugin ${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -g -O3 -UNDEBUG")
+  set(CMAKE_C_FLAGS_RELEASE "-g -O3 -flto -fuse-linker-plugin ${CMAKE_C_FLAGS_RELEASE} -UNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELEASE "-g -O3 -flto -fuse-linker-plugin ${CMAKE_CXX_FLAGS_RELEASE} -UNDEBUG")
+  set(CMAKE_EXE_LINKER_FLAGS "-g -fuse-linker-plugin ${CMAKE_EXE_LINKER_FLAGS}")
+  set(CMAKE_SHARED_LINKER_FLAGS "-g -fuse-linker-plugin ${CMAKE_SHARED_LINKER_FLAGS}")
+endif ()
+
+## set warnings
+set_cflags_if_supported(
+  -Wextra
+  -Wbad-function-cast
+  -Wno-missing-noreturn
+  -Wstrict-prototypes
+  -Wmissing-prototypes
+  -Wmissing-declarations
+  -Wpointer-arith
+  -Wmissing-format-attribute
+  -Wshadow
+  ## other flags to try:
+  #-Wunsafe-loop-optimizations
+  #-Wpointer-arith
+  #-Wc++-compat
+  #-Wc++11-compat
+  #-Wwrite-strings
+  #-Wzero-as-null-pointer-constant
+  #-Wlogical-op
+  #-Wvector-optimization-performance
+  )
+
+if (NOT CMAKE_CXX_COMPILER_ID STREQUAL Clang)
+  # Disabling -Wcast-align with clang.  TODO: fix casting and re-enable it, someday.
+  set_cflags_if_supported(-Wcast-align)
+endif ()
+
+## always want these
+set(CMAKE_C_FLAGS "-Wall -Werror ${CMAKE_C_FLAGS}")
+set(CMAKE_CXX_FLAGS "-Wall -Werror ${CMAKE_CXX_FLAGS}")
+
+## need to set -stdlib=libc++ to get real c++11 support on darwin
+if (APPLE)
+  if (CMAKE_GENERATOR STREQUAL Xcode)
+    set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+  else ()
+    add_definitions(-stdlib=libc++)
+  endif ()
+endif ()
+
+# pick language dialect
+set(CMAKE_C_FLAGS "-std=c99 ${CMAKE_C_FLAGS}")
+check_cxx_compiler_flag(-std=c++11 HAVE_STDCXX11)
+check_cxx_compiler_flag(-std=c++0x HAVE_STDCXX0X)
+if (HAVE_STDCXX11)
+  set(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
+elseif (HAVE_STDCXX0X)
+  set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
+else ()
+  message(FATAL_ERROR "${CMAKE_CXX_COMPILER} doesn't support -std=c++11 or -std=c++0x, you need one that does.")
+endif ()
+
+function(add_space_separated_property type obj propname val)
+  get_property(oldval ${type} ${obj} PROPERTY ${propname})
+  if (oldval MATCHES NOTFOUND)
+    set_property(${type} ${obj} PROPERTY ${propname} "${val}")
+  else ()
+    set_property(${type} ${obj} PROPERTY ${propname} "${val} ${oldval}")
+  endif ()
+endfunction(add_space_separated_property)
+
+## this function makes sure that the libraries passed to it get compiled
+## with gcov-needed flags, we only add those flags to our libraries
+## because we don't really care whether our tests get covered
+function(maybe_add_gcov_to_libraries)
+  if (USE_GCOV)
+    foreach(lib ${ARGN})
+      add_space_separated_property(TARGET ${lib} COMPILE_FLAGS --coverage)
+      add_space_separated_property(TARGET ${lib} LINK_FLAGS --coverage)
+      target_link_libraries(${lib} LINK_PRIVATE gcov)
+    endforeach(lib)
+  endif (USE_GCOV)
+endfunction(maybe_add_gcov_to_libraries)

storage/tokudb/PerconaFT/cmake_modules/TokuThirdParty.cmake

+include(ExternalProject)
+
+if (CMAKE_PROJECT_NAME STREQUAL TokuDB)
+    ## add jemalloc with an external project
+    set(JEMALLOC_SOURCE_DIR "${TokuDB_SOURCE_DIR}/third_party/jemalloc" CACHE FILEPATH "Where to find jemalloc sources.")
+    if (EXISTS "${JEMALLOC_SOURCE_DIR}/configure")
+        set(jemalloc_configure_opts "CC=${CMAKE_C_COMPILER}" "--with-jemalloc-prefix=" "--with-private-namespace=tokudb_jemalloc_internal_" "--enable-cc-silence")
+        option(JEMALLOC_DEBUG "Build jemalloc with --enable-debug." OFF)
+        if (JEMALLOC_DEBUG)
+            list(APPEND jemalloc_configure_opts --enable-debug)
+        endif ()
+        ExternalProject_Add(build_jemalloc
+            PREFIX jemalloc
+            SOURCE_DIR "${JEMALLOC_SOURCE_DIR}"
+            CONFIGURE_COMMAND
+                "${JEMALLOC_SOURCE_DIR}/configure" ${jemalloc_configure_opts}
+                "--prefix=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/jemalloc"
+        )
+
+        add_library(jemalloc STATIC IMPORTED GLOBAL)
+        set_target_properties(jemalloc PROPERTIES IMPORTED_LOCATION
+            "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/jemalloc/lib/libjemalloc_pic.a")
+        add_dependencies(jemalloc build_jemalloc)
+        add_library(jemalloc_nopic STATIC IMPORTED GLOBAL)
+        set_target_properties(jemalloc_nopic PROPERTIES IMPORTED_LOCATION
+            "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/jemalloc/lib/libjemalloc.a")
+        add_dependencies(jemalloc_nopic build_jemalloc)
+
+        # detect when we are being built as a subproject
+        if (NOT DEFINED MYSQL_PROJECT_NAME_DOCSTRING)
+            install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/jemalloc/lib" DESTINATION .
+                COMPONENT tokukv_libs_extra)
+        endif ()
+    endif ()
+endif ()
+
+## add lzma with an external project
+set(xz_configure_opts --with-pic --enable-static)
+if (APPLE)
+  ## lzma has some assembly that doesn't work on darwin
+  list(APPEND xz_configure_opts --disable-assembler)
+endif ()
+
+list(APPEND xz_configure_opts "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}")
+if (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL drd)
+  list(APPEND xz_configure_opts --enable-debug)
+endif ()
+
+set(XZ_SOURCE_DIR "${TokuDB_SOURCE_DIR}/third_party/xz-4.999.9beta" CACHE FILEPATH "Where to find sources for xz (lzma).")
+if (NOT EXISTS "${XZ_SOURCE_DIR}/configure")
+    message(FATAL_ERROR "Can't find the xz sources.  Please check them out to ${XZ_SOURCE_DIR} or modify XZ_SOURCE_DIR.")
+endif ()
+
+if (CMAKE_GENERATOR STREQUAL Ninja)
+  ## ninja doesn't understand "$(MAKE)"
+  set(SUBMAKE_COMMAND make)
+else ()
+  ## use "$(MAKE)" for submakes so they can use the jobserver, doesn't
+  ## seem to break Xcode...
+  set(SUBMAKE_COMMAND $(MAKE))
+endif ()
+
+FILE(GLOB XZ_ALL_FILES ${XZ_SOURCE_DIR}/*)
+ExternalProject_Add(build_lzma
+    PREFIX xz
+    DOWNLOAD_COMMAND
+        cp -a "${XZ_ALL_FILES}" "<SOURCE_DIR>/"
+    CONFIGURE_COMMAND
+        "<SOURCE_DIR>/configure" ${xz_configure_opts}
+        "--prefix=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz"
+        "--libdir=${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/lib"
+    BUILD_COMMAND
+        ${SUBMAKE_COMMAND} -C src/liblzma
+    INSTALL_COMMAND
+        ${SUBMAKE_COMMAND} -C src/liblzma install
+)
+FILE(GLOB_RECURSE XZ_ALL_FILES_RECURSIVE ${XZ_SOURCE_DIR}/*)
+ExternalProject_Add_Step(build_lzma reclone_src # Names of project and custom step
+    COMMENT "(re)cloning xz source..."     # Text printed when step executes
+    DEPENDERS download configure   # Steps that depend on this step
+    DEPENDS   ${XZ_ALL_FILES_RECURSIVE}   # Files on which this step depends
+)
+
+set_source_files_properties(
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/base.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/bcj.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/block.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/check.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/container.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/delta.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/filter.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/index.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/index_hash.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/lzma.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/stream_flags.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/subblock.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/version.h"
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include/lzma/vli.h"
+  PROPERTIES GENERATED TRUE)
+
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/include")
+
+add_library(lzma STATIC IMPORTED)
+set_target_properties(lzma PROPERTIES IMPORTED_LOCATION
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/xz/lib/liblzma.a")
+add_dependencies(lzma build_lzma)
+
+
+## add snappy with an external project
+set(SNAPPY_SOURCE_DIR "${TokuDB_SOURCE_DIR}/third_party/snappy-1.1.2" CACHE FILEPATH "Where to find sources for snappy.")
+if (NOT EXISTS "${SNAPPY_SOURCE_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Can't find the snappy sources.  Please check them out to ${SNAPPY_SOURCE_DIR} or modify SNAPPY_SOURCE_DIR.")
+endif ()
+
+FILE(GLOB SNAPPY_ALL_FILES ${SNAPPY_SOURCE_DIR}/*)
+ExternalProject_Add(build_snappy
+    PREFIX snappy
+    DOWNLOAD_COMMAND
+        cp -a "${SNAPPY_ALL_FILES}" "<SOURCE_DIR>/"
+    CMAKE_ARGS
+        -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        ${USE_PROJECT_CMAKE_MODULE_PATH}
+)
+FILE(GLOB_RECURSE SNAPPY_ALL_FILES_RECURSIVE ${SNAPPY_SOURCE_DIR}/*)
+ExternalProject_Add_Step(build_snappy reclone_src # Names of project and custom step
+    COMMENT "(re)cloning snappy source..."     # Text printed when step executes
+    DEPENDERS download configure   # Steps that depend on this step
+    DEPENDS   ${SNAPPY_ALL_FILES_RECURSIVE}   # Files on which this step depends
+)
+
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/snappy/include")
+
+add_library(snappy STATIC IMPORTED)
+set_target_properties(snappy PROPERTIES IMPORTED_LOCATION
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/snappy/lib/libsnappy.a")
+add_dependencies(snappy build_snappy)

storage/tokudb/PerconaFT/ft/CMakeLists.txt

+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+## generate log_code.cc, log_print.cc, log_header.cc
+set_source_files_properties(
+  "${CMAKE_CURRENT_BINARY_DIR}/log_code"
+  "${CMAKE_CURRENT_BINARY_DIR}/log_print"
+  "${CMAKE_CURRENT_BINARY_DIR}/log_header.h"
+  PROPERTIES GENERATED TRUE)
+
+add_executable(logformat logger/logformat.cc)
+target_link_libraries(logformat ${LIBTOKUPORTABILITY}_static)
+if (USE_GCOV)
+   add_space_separated_property(TARGET logformat LINK_FLAGS --coverage)
+endif (USE_GCOV)
+
+add_custom_command(
+  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/log_code.cc"
+  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/log_print.cc"
+  OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/log_header.h"
+  COMMAND $<TARGET_FILE:logformat> .
+  DEPENDS logger/logformat
+  )
+add_custom_target(
+  generate_log_code
+  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/log_code.cc" "${CMAKE_CURRENT_BINARY_DIR}/log_print.cc" "${CMAKE_CURRENT_BINARY_DIR}/log_header.h"
+  )
+
+set(FT_SOURCES
+  bndata
+  cachetable/background_job_manager
+  cachetable/cachetable
+  cachetable/checkpoint
+  cursor
+  ft
+  ft-cachetable-wrappers
+  ft-flusher
+  ft-hot-flusher
+  ft-ops
+  ft-status
+  ft-test-helpers
+  ft-verify
+  loader/callbacks
+  loader/dbufio
+  loader/loader
+  loader/pqueue
+  leafentry
+  le-cursor
+  logger/logcursor
+  logger/logfilemgr
+  logger/logger
+  logger/log_upgrade
+  logger/recover
+  msg
+  msg_buffer
+  node
+  pivotkeys
+  serialize/block_allocator
+  serialize/block_allocator_strategy
+  serialize/block_table
+  serialize/compress
+  serialize/ft_node-serialize
+  serialize/ft-node-deserialize
+  serialize/ft-serialize
+  serialize/quicklz
+  serialize/sub_block
+  txn/rollback
+  txn/rollback-apply
+  txn/rollback-ct-callbacks
+  txn/rollback_log_node_cache
+  txn/roll
+  txn/txn
+  txn/txn_child_manager
+  txn/txn_manager
+  txn/xids
+  ule
+  "${CMAKE_CURRENT_BINARY_DIR}/log_code"
+  "${CMAKE_CURRENT_BINARY_DIR}/log_print"
+  )
+
+add_library(ft SHARED ${FT_SOURCES})
+add_library(ft_static STATIC ${FT_SOURCES})
+## we're going to link this into libtokudb.so so it needs to have PIC
+set_target_properties(ft_static PROPERTIES POSITION_INDEPENDENT_CODE ON)
+maybe_add_gcov_to_libraries(ft ft_static)
+
+## depend on other generated targets
+add_dependencies(ft install_tdb_h generate_log_code build_lzma build_snappy)
+add_dependencies(ft_static install_tdb_h generate_log_code build_lzma build_snappy)
+
+## link with lzma (which should be static) and link dependers with zlib
+target_link_libraries(ft LINK_PRIVATE util_static lzma snappy ${LIBTOKUPORTABILITY})
+target_link_libraries(ft LINK_PUBLIC z)
+target_link_libraries(ft_static LINK_PRIVATE lzma snappy)
+
+add_subdirectory(tests)

storage/tokudb/PerconaFT/ft/cachetable/background_job_manager.cc

+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
+#ident "$Id$"
+/*======
+This file is part of PerconaFT.
+
+
+Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
+
+    PerconaFT is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License, version 2,
+    as published by the Free Software Foundation.
+
+    PerconaFT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
+
+----------------------------------------
+
+    PerconaFT is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License, version 3,
+    as published by the Free Software Foundation.
+
+    PerconaFT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
+======= */
+
+#ident "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
+
+#include <portability/toku_config.h>
+#include <memory.h>
+#include <toku_pthread.h>
+
+#include "cachetable/background_job_manager.h"
+
+struct background_job_manager_struct {
+    bool accepting_jobs;
+    uint32_t num_jobs;
+    toku_cond_t jobs_wait;
+    toku_mutex_t jobs_lock;
+};
+
+void bjm_init(BACKGROUND_JOB_MANAGER* pbjm) {
+    BACKGROUND_JOB_MANAGER XCALLOC(bjm);
+    toku_mutex_init(&bjm->jobs_lock, 0);    
+    toku_cond_init(&bjm->jobs_wait, NULL);
+    bjm->accepting_jobs = true;
+    bjm->num_jobs = 0;
+    *pbjm = bjm;
+}
+
+void bjm_destroy(BACKGROUND_JOB_MANAGER bjm) {
+    assert(bjm->num_jobs == 0);
+    toku_cond_destroy(&bjm->jobs_wait);
+    toku_mutex_destroy(&bjm->jobs_lock);
+    toku_free(bjm);
+}
+
+void bjm_reset(BACKGROUND_JOB_MANAGER bjm) {
+    toku_mutex_lock(&bjm->jobs_lock);
+    assert(bjm->num_jobs == 0);
+    bjm->accepting_jobs = true;
+    toku_mutex_unlock(&bjm->jobs_lock);
+}
+
+int bjm_add_background_job(BACKGROUND_JOB_MANAGER bjm) {
+    int ret_val;
+    toku_mutex_lock(&bjm->jobs_lock);
+    if (bjm->accepting_jobs) {
+        bjm->num_jobs++;
+        ret_val = 0;
+    }
+    else {
+        ret_val = -1;
+    }
+    toku_mutex_unlock(&bjm->jobs_lock);
+    return ret_val;
+}
+void bjm_remove_background_job(BACKGROUND_JOB_MANAGER bjm){
+    toku_mutex_lock(&bjm->jobs_lock);
+    assert(bjm->num_jobs > 0);
+    bjm->num_jobs--;
+    if (bjm->num_jobs == 0 && !bjm->accepting_jobs) {
+        toku_cond_broadcast(&bjm->jobs_wait);
+    }
+    toku_mutex_unlock(&bjm->jobs_lock);
+}
+
+void bjm_wait_for_jobs_to_finish(BACKGROUND_JOB_MANAGER bjm) {
+    toku_mutex_lock(&bjm->jobs_lock);
+    bjm->accepting_jobs = false;
+    while (bjm->num_jobs > 0) {
+        toku_cond_wait(&bjm->jobs_wait, &bjm->jobs_lock);
+    }
+    toku_mutex_unlock(&bjm->jobs_lock);
+}
+

storage/tokudb/PerconaFT/ft/cachetable/background_job_manager.h

+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
+#ident "$Id$"
+/*======
+This file is part of PerconaFT.
+
+
+Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved.
+
+    PerconaFT is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License, version 2,
+    as published by the Free Software Foundation.
+
+    PerconaFT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
+
+----------------------------------------
+
+    PerconaFT is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License, version 3,
+    as published by the Free Software Foundation.
+
+    PerconaFT is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with PerconaFT.  If not, see <http://www.gnu.org/licenses/>.
+======= */
+
+#ident "Copyright (c) 2006, 2015, Percona and/or its affiliates. All rights reserved."
+
+#pragma once
+
+//
+// The background job manager keeps track of the existence of 
+// background jobs running. We use the background job manager
+// to allow threads to perform background jobs on various pieces 
+// of the system (e.g. cachefiles and cloned pairs being written out 
+// for checkpoint)
+//
+
+typedef struct background_job_manager_struct *BACKGROUND_JOB_MANAGER;
+
+
+void bjm_init(BACKGROUND_JOB_MANAGER* bjm);
+void bjm_destroy(BACKGROUND_JOB_MANAGER bjm);
+
+//
+// Re-allows a background job manager to accept background jobs
+//
+void bjm_reset(BACKGROUND_JOB_MANAGER bjm);
+
+//
+// add a background job. If return value is 0, then the addition of the job
+// was successful and the user may perform the background job. If return
+// value is non-zero, then adding of the background job failed and the user
+// may not perform the background job.
+//
+int bjm_add_background_job(BACKGROUND_JOB_MANAGER bjm);
+
+//
+// remove a background job
+//
+void bjm_remove_background_job(BACKGROUND_JOB_MANAGER bjm);
+
+//
+// This function waits for all current background jobs to be removed. If the user
+// calls bjm_add_background_job while this function is running, or after this function
+// has completed, bjm_add_background_job returns an error. 
+//
+void bjm_wait_for_jobs_to_finish(BACKGROUND_JOB_MANAGER bjm);