Merge pull request #1 from yiwu-arbug/repo_init

Summary:
Adding a cmake script so we can build static lib for Titan:
* build static lib libtitan.a, titandb_bench, titandb_stress, and unit tests.
* the script should generate the same compile and link flags (by copying part of rocksdb/CMakeLists.txt into cmake/rocksdb_flags.cmake)
* See the new README.md file for build script usage

Other changes:
* updated README.md
* updated header paths
* remove titan_c.h and titan_c.cc, which is not being used anywhere
* add a .gitignore

Test Plan:
```
mkdir -p build; 
cd build; 
cmake .. -DROCKSDB_DIR=../rocksdb;
make -j
ctest -R titan
```

.gitignore

+*.a
+*.o
+*.swp
+*_test
+titandb_bench
+titandb_stress
+
+build/
+.idea/
+.vscode/

CMakeLists.txt

+cmake_minimum_required(VERSION 3.0)
+project(titan)
+enable_language(CXX)
+enable_language(C)
+
+if (NOT DEFINED ROCKSDB_DIR)
+  message(FATAL_ERROR "ROCKSDB_DIR is not defined.")
+endif()
+
+include(cmake/rocksdb_flags.cmake)
+
+include_directories(${ROCKSDB_DIR})
+include_directories(${ROCKSDB_DIR}/include)
+include_directories(${PROJECT_SOURCE_DIR}/include)
+include_directories(${PROJECT_SOURCE_DIR}/src)
+
+set(SOURCES
+        src/blob_file_builder.cc
+        src/blob_file_cache.cc
+        src/blob_file_iterator.cc
+        src/blob_file_reader.cc
+        src/blob_file_size_collector.cc
+        src/base_db_listener.cc
+        src/blob_format.cc
+        src/blob_gc.cc
+        src/blob_gc_job.cc
+        src/blob_gc_picker.cc
+        src/db.cc
+        src/db_impl.cc
+        src/db_impl_files.cc
+        src/db_impl_gc.cc
+        src/options.cc
+        src/table_builder.cc
+        src/table_factory.cc
+        src/util.cc
+        src/version.cc
+        src/version_edit.cc
+        src/version_set.cc)
+
+add_library(titan STATIC ${SOURCES})
+
+option(WITH_TITAN_TESTS "Build with tests." ON)
+option(WITH_TITAN_TOOLS "Build with tools." ON)
+
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
+  set(WITH_TITAN_TESTS OFF)
+  set(WITH_TITAN_TOOLS OFF)
+endif()
+
+if (WITH_TITAN_TESTS OR WITH_TITAN_TOOLS)
+  add_subdirectory(${ROCKSDB_DIR} rocksdb EXCLUDE_FROM_ALL)
+endif()
+
+if (WITH_TITAN_TESTS)
+  include(CTest)
+  find_package(Threads REQUIRED)
+  find_package(GTest REQUIRED)
+  set(TESTS
+        blob_file_iterator_test
+        blob_file_size_collector_test
+        blob_file_test
+        blob_format_test
+        blob_gc_job_test
+        blob_gc_picker_test
+        table_builder_test
+        titan_db_test
+        util_test
+        version_test)
+  set(TEST_LIBS
+        titan
+        rocksdb
+        testharness
+        testutillib
+        Threads::Threads
+        GTest::GTest)
+        
+  foreach(test ${TESTS})
+      add_executable(titan_${test} src/${test}.cc)
+      target_include_directories(titan_${test} PRIVATE ${GTEST_INCLUDE_DIRS})
+      target_link_libraries(titan_${test} ${TEST_LIBS})
+      add_test(titan_${test} titan_${test})
+  endforeach(test ${TESTS})  
+endif()
+
+if (WITH_TITAN_TOOLS)
+  find_package(gflags REQUIRED)
+  add_definitions(-DGFLAGS)
+
+  set(TOOLS_LIBS
+        titan
+        rocksdb)
+
+  add_executable(titandb_stress tools/titandb_stress.cc)
+  target_include_directories(titandb_stress PRIVATE ${gflags_INCLUDE_DIR})
+  target_link_libraries(titandb_stress ${TOOLS_LIBS})
+
+  add_executable(titandb_bench tools/db_bench.cc tools/db_bench_tool.cc)
+  target_include_directories(titandb_bench PRIVATE ${gflags_INCLUDE_DIR})
+  target_link_libraries(titandb_bench ${TOOLS_LIBS})
+endif()

README.md

-# titan
\ No newline at end of file
+# Titan: A RocksDB Plugin to Reduce Write Amplification
+
+Titan is a RocksDB Plugin for key-value separation, inspired by 
+[WiscKey](https://www.usenix.org/system/files/conference/fast16/fast16-papers-lu.pdf).
+For introduction and design details, see our
+[blog post](https://pingcap.com/blog/titan-storage-engine-design-and-implementation/).
+
+## Build and Test
+Titan relies on RocksDB source code to build. You need to checkout RocksDB source code locally,
+and provide the path to Titan build script.
+```
+# To build:
+mkdir -p build
+cd build
+cmake .. -DROCKSDB_DIR=<rocksdb_source_dir>
+make -j<n>
+
+# Build static lib (i.e. libtitan.a) only:
+make titan -j<n>
+
+# Release build:
+cmake .. -DROCKSDB_DIR=<rocksdb_source_dir> -DCMAKE_BUILD_TYPE=Release
+
+# Building with sanitizer (e.g. ASAN):
+cmake .. -DROCKSDB_DIR=<rocksdb_source_dir> -DWITH_ASAN=ON
+
+# Building with compression libraries (e.g. snappy):
+cmake .. -DROCKSDB_DIR=<rocksdb_source_dir> -DWITH_SNAPPY=ON
+
+# Run tests after build. You need to filter tests by "titan" prefix.
+ctest -R titan
+```

cmake/rocksdb_flags.cmake

+# Generate compile and link flags
+# Extracted from rocksdb/CMakeLists.txt
+
+if(MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4800 /wd4996 /wd4351 /wd4100 /wd4204 /wd4324")
+else()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing")
+  if(MINGW)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-format")
+  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+  if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
+    include(CheckCXXCompilerFlag)
+    CHECK_CXX_COMPILER_FLAG("-momit-leaf-frame-pointer" HAVE_OMIT_LEAF_FRAME_POINTER)
+    if(HAVE_OMIT_LEAF_FRAME_POINTER)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -momit-leaf-frame-pointer")
+    endif()
+  endif()
+endif()
+
+include(CheckCCompilerFlag)
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")
+  CHECK_C_COMPILER_FLAG("-maltivec" HAS_ALTIVEC)
+  if(HAS_ALTIVEC)
+    message(STATUS " HAS_ALTIVEC yes")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maltivec")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maltivec")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mcpu=power8")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=power8")
+  endif(HAS_ALTIVEC)
+endif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")
+
+option(PORTABLE "build a portable binary" OFF)
+option(FORCE_SSE42 "force building with SSE4.2, even when PORTABLE=ON" OFF)
+if(PORTABLE)
+  # MSVC does not need a separate compiler flag to enable SSE4.2; if nmmintrin.h
+  # is available, it is available by default.
+  if(FORCE_SSE42 AND NOT MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2 -mpclmul")
+  endif()
+else()
+  if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
+  else()
+    if(NOT HAVE_POWER8)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+    endif()
+  endif()
+endif()
+
+include(CheckCXXSourceCompiles)
+if(NOT MSVC)
+  set(CMAKE_REQUIRED_FLAGS "-msse4.2 -mpclmul")
+endif()
+CHECK_CXX_SOURCE_COMPILES("
+#include <cstdint>
+#include <nmmintrin.h>
+#include <wmmintrin.h>
+int main() {
+  volatile uint32_t x = _mm_crc32_u32(0, 0);
+  const auto a = _mm_set_epi64x(0, 0);
+  const auto b = _mm_set_epi64x(0, 0);
+  const auto c = _mm_clmulepi64_si128(a, b, 0x00);
+  auto d = _mm_cvtsi128_si64(c);
+}
+" HAVE_SSE42)
+unset(CMAKE_REQUIRED_FLAGS)
+if(HAVE_SSE42)
+  add_definitions(-DHAVE_SSE42)
+  add_definitions(-DHAVE_PCLMUL)
+elseif(FORCE_SSE42)
+  message(FATAL_ERROR "FORCE_SSE42=ON but unable to compile with SSE4.2 enabled")
+endif()
+
+CHECK_CXX_SOURCE_COMPILES("
+#if defined(_MSC_VER) && !defined(__thread)
+#define __thread __declspec(thread)
+#endif
+int main() {
+  static __thread int tls;
+}
+" HAVE_THREAD_LOCAL)
+if(HAVE_THREAD_LOCAL)
+  add_definitions(-DROCKSDB_SUPPORT_THREAD_LOCAL)
+endif()
+
+option(FAIL_ON_WARNINGS "Treat compile warnings as errors" ON)
+if(FAIL_ON_WARNINGS)
+  if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
+  else() # assume GCC
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+  endif()
+endif()
+
+option(WITH_ASAN "build with ASAN" OFF)
+if(WITH_ASAN)
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
+  if(WITH_JEMALLOC)
+    message(FATAL "ASAN does not work well with JeMalloc")
+  endif()
+endif()
+
+option(WITH_TSAN "build with TSAN" OFF)
+if(WITH_TSAN)
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread -pie")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread -fPIC")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread -fPIC")
+  if(WITH_JEMALLOC)
+    message(FATAL "TSAN does not work well with JeMalloc")
+  endif()
+endif()
+
+option(WITH_UBSAN "build with UBSAN" OFF)
+if(WITH_UBSAN)
+  add_definitions(-DROCKSDB_UBSAN_RUN)
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
+  if(WITH_JEMALLOC)
+    message(FATAL "UBSAN does not work well with JeMalloc")
+  endif()
+endif()
+
+# Stall notifications eat some performance from inserts
+option(DISABLE_STALL_NOTIF "Build with stall notifications" OFF)
+if(DISABLE_STALL_NOTIF)
+  add_definitions(-DROCKSDB_DISABLE_STALL_NOTIFICATION)
+endif()
+
+
+if(DEFINED USE_RTTI)
+  if(USE_RTTI)
+    message(STATUS "Enabling RTTI")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DROCKSDB_USE_RTTI")
+  else()
+    if(MSVC)
+      message(STATUS "Disabling RTTI in Release builds. Always on in Debug.")
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
+    else()
+      message(STATUS "Disabling RTTI in Release builds")
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-rtti")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
+    endif()
+  endif()
+else()
+  message(STATUS "Enabling RTTI in Debug builds only (default)")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DROCKSDB_USE_RTTI")
+  if(MSVC)
+     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GR-")
+  else()
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fno-rtti")
+  endif()
+endif()
+
+# Used to run CI build and tests so we can run faster
+option(OPTDBG "Build optimized debug build with MSVC" OFF)
+option(WITH_RUNTIME_DEBUG "build with debug version of runtime library" ON)
+if(MSVC)
+  if(OPTDBG)
+    message(STATUS "Debug optimization is enabled")
+    set(CMAKE_CXX_FLAGS_DEBUG "/Oxt")
+  else()
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /RTC1 /Gm")
+  endif()
+  if(WITH_RUNTIME_DEBUG)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /${RUNTIME_LIBRARY}d")
+  else()
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /${RUNTIME_LIBRARY}")
+  endif()
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Oxt /Zp8 /Gm- /Gy /${RUNTIME_LIBRARY}")
+
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG")
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-memcmp")
+endif()
+
+option(ROCKSDB_LITE "Build RocksDBLite version" OFF)
+if(ROCKSDB_LITE)
+  add_definitions(-DROCKSDB_LITE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -Os")
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "Cygwin")
+  add_definitions(-fno-builtin-memcmp -DCYGWIN)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  add_definitions(-DOS_MACOSX)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES arm)
+    add_definitions(-DIOS_CROSS_COMPILE -DROCKSDB_LITE)
+    # no debug info for IOS, that will make our library big
+    add_definitions(-DNDEBUG)
+  endif()
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
+  add_definitions(-DOS_LINUX)
+elseif(CMAKE_SYSTEM_NAME MATCHES "SunOS")
+  add_definitions(-DOS_SOLARIS)
+elseif(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+  add_definitions(-DOS_FREEBSD)
+elseif(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
+  add_definitions(-DOS_NETBSD)
+elseif(CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
+  add_definitions(-DOS_OPENBSD)
+elseif(CMAKE_SYSTEM_NAME MATCHES "DragonFly")
+  add_definitions(-DOS_DRAGONFLYBSD)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
+  add_definitions(-DOS_ANDROID)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Windows")
+  add_definitions(-DWIN32 -DOS_WIN -D_MBCS -DWIN64 -DNOMINMAX)
+  if(MINGW)
+    add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_VISTA)
+  endif()
+endif()
+
+if(NOT WIN32)
+  add_definitions(-DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX)
+endif()
+
+option(WITH_FALLOCATE "build with fallocate" ON)
+if(WITH_FALLOCATE)
+  CHECK_CXX_SOURCE_COMPILES("
+#include <fcntl.h>
+#include <linux/falloc.h>
+int main() {
+ int fd = open(\"/dev/null\", 0);
+ fallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE, 0, 1024);
+}
+" HAVE_FALLOCATE)
+  if(HAVE_FALLOCATE)
+    add_definitions(-DROCKSDB_FALLOCATE_PRESENT)
+  endif()
+endif()
+
+CHECK_CXX_SOURCE_COMPILES("
+#include <fcntl.h>
+int main() {
+  int fd = open(\"/dev/null\", 0);
+  sync_file_range(fd, 0, 1024, SYNC_FILE_RANGE_WRITE);
+}
+" HAVE_SYNC_FILE_RANGE_WRITE)
+if(HAVE_SYNC_FILE_RANGE_WRITE)
+  add_definitions(-DROCKSDB_RANGESYNC_PRESENT)
+endif()
+
+CHECK_CXX_SOURCE_COMPILES("
+#include <pthread.h>
+int main() {
+  (void) PTHREAD_MUTEX_ADAPTIVE_NP;
+}
+" HAVE_PTHREAD_MUTEX_ADAPTIVE_NP)
+if(HAVE_PTHREAD_MUTEX_ADAPTIVE_NP)
+  add_definitions(-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX)
+endif()
+
+include(CheckCXXSymbolExists)
+check_cxx_symbol_exists(malloc_usable_size malloc.h HAVE_MALLOC_USABLE_SIZE)
+if(HAVE_MALLOC_USABLE_SIZE)
+  add_definitions(-DROCKSDB_MALLOC_USABLE_SIZE)
+endif()
+
+check_cxx_symbol_exists(sched_getcpu sched.h HAVE_SCHED_GETCPU)
+if(HAVE_SCHED_GETCPU)
+  add_definitions(-DROCKSDB_SCHED_GETCPU_PRESENT)
+endif()

include/titan/db.h

 #pragma once
 
 #include "rocksdb/utilities/stackable_db.h"
-#include "utilities/titandb/options.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

include/titan/titan_c.h

-/*
-  C bindings for TitanDB.  May be useful as a stable ABI that can be
-  used by programs that keep rocksdb in a shared library, or for
-  a JNI api.
-
-  Does not support:
-  . getters for the option types
-  . custom comparators that implement key shortening
-  . capturing post-write-snapshot
-  . custom iter, db, env, cache implementations using just the C bindings
-
-  Some conventions:
-
-  (1) We expose just opaque struct pointers and functions to clients.
-  This allows us to change internal representations without having to
-  recompile clients.
-
-  (2) For simplicity, there is no equivalent to the Slice type.  Instead,
-  the caller has to pass the pointer and length as separate
-  arguments.
-
-  (3) Errors are represented by a null-terminated c string.  NULL
-  means no error.  All operations that can raise an error are passed
-  a "char** errptr" as the last argument.  One of the following must
-  be true on entry:
-     *errptr == NULL
-     *errptr points to a malloc()ed null-terminated error message
-  On success, a leveldb routine leaves *errptr unchanged.
-  On failure, leveldb frees the old value of *errptr and
-  set *errptr to a malloc()ed error message.
-
-  (4) Bools have the type unsigned char (0 == false; rest == true)
-
-  (5) All of the pointer arguments must be non-NULL.
-*/
-
-#ifndef ROCKSDB_TITAN_C_H
-#define ROCKSDB_TITAN_C_H
-
-#pragma once
-
-#ifdef _WIN32
-#ifdef ROCKSDB_DLL
-#ifdef ROCKSDB_LIBRARY_EXPORTS
-#define ROCKSDB_LIBRARY_API __declspec(dllexport)
-#else
-#define ROCKSDB_LIBRARY_API __declspec(dllimport)
-#endif
-#else
-#define ROCKSDB_LIBRARY_API
-#endif
-#else
-#define ROCKSDB_LIBRARY_API
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdint.h>
-#include "rocksdb/c.h"
-
-/* Exported types */
-
-// TitanDB
-
-typedef struct titandb_options_t titandb_options_t;
-
-extern ROCKSDB_LIBRARY_API rocksdb_t* titandb_open(
-    const titandb_options_t* options, const char* name, char** errptr);
-
-extern ROCKSDB_LIBRARY_API titandb_options_t* titandb_options_create();
-
-extern ROCKSDB_LIBRARY_API void titandb_options_destroy(titandb_options_t*);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_rocksdb(
-    titandb_options_t* options, rocksdb_options_t* rocksdb);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_dirname(
-    titandb_options_t* options, const char* name);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_min_blob_size(
-    titandb_options_t* options, uint64_t size);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_blob_file_compression(
-    titandb_options_t* options, int compression);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_blob_cache(
-    titandb_options_t* options, rocksdb_cache_t* blob_cache);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_disable_background_gc(
-    titandb_options_t* options, unsigned char disable);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_max_gc_batch_size(
-    titandb_options_t* options, uint64_t size);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_min_gc_batch_size(
-    titandb_options_t* options, uint64_t size);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_blob_file_discardable_ratio(
-    titandb_options_t* options, float ratio);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_sample_file_size_ratio(
-    titandb_options_t* options, float ratio);
-
-extern ROCKSDB_LIBRARY_API void titandb_options_set_merge_small_file_threshold(
-    titandb_options_t* options, uint64_t size);
-
-#ifdef __cplusplus
-} /* end extern "C" */
-#endif
-
-#endif  // ROCKSDB_TITAN_C_H

src/base_db_listener.h

 #pragma once
 
 #include "rocksdb/listener.h"
-#include "utilities/titandb/db_impl.h"
+#include "db_impl.h"
 
 namespace rocksdb {
 

src/blob_file_builder.cc

-#include "utilities/titandb/blob_file_builder.h"
+#include "blob_file_builder.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_builder.h

 #pragma once
 
 #include "util/file_reader_writer.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/options.h"
+#include "blob_format.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_cache.cc

-#include "utilities/titandb/blob_file_cache.h"
+#include "blob_file_cache.h"
 
 #include "util/filename.h"
-#include "utilities/titandb/util.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_cache.h

 #pragma once
 
 #include "rocksdb/options.h"
-#include "utilities/titandb/blob_file_reader.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/options.h"
+#include "blob_file_reader.h"
+#include "blob_format.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_iterator.cc

-#include "utilities/titandb/blob_file_iterator.h"
+#include "blob_file_iterator.h"
 
 #include "util/crc32c.h"
-#include "utilities/titandb/util.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_iterator.h

@@ -7,9 +7,9 @@
 #include "rocksdb/status.h"
 #include "table/internal_iterator.h"
 #include "util/file_reader_writer.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/options.h"
-#include "utilities/titandb/util.h"
+#include "blob_format.h"
+#include "titan/options.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_iterator_test.cc

-#include "utilities/titandb/blob_file_iterator.h"
+#include "blob_file_iterator.h"
 
 #include <cinttypes>
 
 #include "util/filename.h"
 #include "util/testharness.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_cache.h"
-#include "utilities/titandb/blob_file_reader.h"
+#include "blob_file_builder.h"
+#include "blob_file_cache.h"
+#include "blob_file_reader.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_manager.h

 #pragma once
 
 #include "util/file_reader_writer.h"
-#include "utilities/titandb/blob_format.h"
+#include "blob_format.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_reader.cc

-#include "utilities/titandb/blob_file_reader.h"
+#include "blob_file_reader.h"
 
 #include "util/crc32c.h"
 #include "util/filename.h"

src/blob_file_reader.h

 #pragma once
 
 #include "util/file_reader_writer.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/options.h"
+#include "blob_format.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_size_collector.cc

-#include "utilities/titandb/blob_file_size_collector.h"
+#include "blob_file_size_collector.h"
 #include "base_db_listener.h"
 
 namespace rocksdb {

src/blob_file_size_collector.h

@@ -3,8 +3,8 @@
 #include "rocksdb/listener.h"
 #include "rocksdb/table_properties.h"
 #include "util/coding.h"
-#include "utilities/titandb/db_impl.h"
-#include "utilities/titandb/version_set.h"
+#include "db_impl.h"
+#include "version_set.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_file_size_collector_test.cc

-#include "utilities/titandb/blob_file_size_collector.h"
+#include "blob_file_size_collector.h"
 #include "util/testharness.h"
 
 namespace rocksdb {

src/blob_file_test.cc

 #include "util/filename.h"
 #include "util/testharness.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_cache.h"
-#include "utilities/titandb/blob_file_reader.h"
+#include "blob_file_builder.h"
+#include "blob_file_cache.h"
+#include "blob_file_reader.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_format.cc

-#include "utilities/titandb/blob_format.h"
+#include "blob_format.h"
 
 #include "util/crc32c.h"
 #include "util/sync_point.h"

src/blob_format.h

@@ -4,7 +4,7 @@
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
 #include "table/format.h"
-#include "utilities/titandb/util.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_format_test.cc

-#include "utilities/titandb/blob_format.h"
+#include "blob_format.h"
 #include "util/testharness.h"
-#include "utilities/titandb/testutil.h"
-#include "utilities/titandb/util.h"
+#include "testutil.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc.cc

-#include "utilities/titandb/blob_gc.h"
+#include "blob_gc.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc.h

@@ -3,8 +3,8 @@
 #include <memory>
 
 #include "db/column_family.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/options.h"
+#include "blob_format.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_job.cc

-#include "utilities/titandb/blob_gc_job.h"
+#include "blob_gc_job.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_job.h

@@ -2,12 +2,12 @@
 
 #include "db/db_impl.h"
 #include "rocksdb/status.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_iterator.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/blob_gc.h"
-#include "utilities/titandb/options.h"
-#include "utilities/titandb/version_set.h"
+#include "blob_file_builder.h"
+#include "blob_file_iterator.h"
+#include "blob_file_manager.h"
+#include "blob_gc.h"
+#include "titan/options.h"
+#include "version_set.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_job_test.cc

-#include "utilities/titandb/blob_gc_job.h"
+#include "blob_gc_job.h"
 
 #include "util/testharness.h"
-#include "utilities/titandb/blob_gc_picker.h"
-#include "utilities/titandb/db_impl.h"
+#include "blob_gc_picker.h"
+#include "db_impl.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_picker.cc

-#include "utilities/titandb/blob_gc_picker.h"
+#include "blob_gc_picker.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_picker.h

@@ -6,10 +6,10 @@
 #include "db/write_callback.h"
 #include "rocksdb/status.h"
 #include "util/filename.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/blob_gc.h"
-#include "utilities/titandb/version.h"
+#include "blob_file_manager.h"
+#include "blob_format.h"
+#include "blob_gc.h"
+#include "version.h"
 
 namespace rocksdb {
 namespace titandb {

src/blob_gc_picker_test.cc

-#include "utilities/titandb/blob_gc_picker.h"
+#include "blob_gc_picker.h"
 
 #include "util/filename.h"
 #include "util/testharness.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_cache.h"
-#include "utilities/titandb/blob_file_iterator.h"
-#include "utilities/titandb/blob_file_reader.h"
+#include "blob_file_builder.h"
+#include "blob_file_cache.h"
+#include "blob_file_iterator.h"
+#include "blob_file_reader.h"
 
 namespace rocksdb {
 namespace titandb {

src/db.cc

-#include "rocksdb/utilities/titandb/db.h"
+#include "titan/db.h"
 
-#include "utilities/titandb/db_impl.h"
+#include "db_impl.h"
 
 namespace rocksdb {
 namespace titandb {

src/db_impl.cc

-#include "utilities/titandb/db_impl.h"
-
-#include "utilities/titandb/base_db_listener.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_iterator.h"
-#include "utilities/titandb/blob_file_size_collector.h"
-#include "utilities/titandb/blob_gc.h"
-#include "utilities/titandb/db_iter.h"
-#include "utilities/titandb/table_factory.h"
+#include "db_impl.h"
+
+#include "base_db_listener.h"
+#include "blob_file_builder.h"
+#include "blob_file_iterator.h"
+#include "blob_file_size_collector.h"
+#include "blob_gc.h"
+#include "db_iter.h"
+#include "table_factory.h"
 
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS

src/db_impl.h

@@ -2,9 +2,9 @@
 
 #include "db/db_impl.h"
 #include "util/repeatable_thread.h"
-#include "rocksdb/utilities/titandb/db.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/version_set.h"
+#include "titan/db.h"
+#include "blob_file_manager.h"
+#include "version_set.h"
 
 namespace rocksdb {
 namespace titandb {

src/db_impl_files.cc

-#include "utilities/titandb/db_impl.h"
+#include "db_impl.h"
 
 namespace rocksdb {
 namespace titandb {

src/db_impl_gc.cc

-#include "utilities/titandb/db_impl.h"
+#include "db_impl.h"
 
-#include "utilities/titandb/blob_file_iterator.h"
-#include "utilities/titandb/blob_gc_job.h"
-#include "utilities/titandb/blob_gc_picker.h"
+#include "blob_file_iterator.h"
+#include "blob_gc_job.h"
+#include "blob_gc_picker.h"
 
 namespace rocksdb {
 namespace titandb {

src/options.cc

-#include "utilities/titandb/options.h"
+#include "titan/options.h"
 
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS

src/table_builder.cc

-#include "utilities/titandb/table_builder.h"
+#include "table_builder.h"
 
 namespace rocksdb {
 namespace titandb {

src/table_builder.h

 #pragma once
 
 #include "table/table_builder.h"
-#include "utilities/titandb/blob_file_builder.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/options.h"
+#include "blob_file_builder.h"
+#include "blob_file_manager.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/table_builder_test.cc

@@ -2,9 +2,9 @@
 #include "table/table_reader.h"
 #include "util/filename.h"
 #include "util/testharness.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/blob_file_reader.h"
-#include "utilities/titandb/table_factory.h"
+#include "blob_file_manager.h"
+#include "blob_file_reader.h"
+#include "table_factory.h"
 
 namespace rocksdb {
 namespace titandb {

src/table_factory.cc

-#include "utilities/titandb/table_factory.h"
+#include "table_factory.h"
 
-#include "utilities/titandb/table_builder.h"
+#include "table_builder.h"
 
 namespace rocksdb {
 namespace titandb {

src/table_factory.h

 #pragma once
 
 #include "rocksdb/table.h"
-#include "utilities/titandb/blob_file_manager.h"
-#include "utilities/titandb/options.h"
+#include "blob_file_manager.h"
+#include "titan/options.h"
 
 namespace rocksdb {
 namespace titandb {

src/titan_c.cc

-#include "rocksdb/utilities/titan_c.h"
-#include "rocksdb/db.h"
-#include "rocksdb/utilities/titandb/db.h"
-
-using rocksdb::Cache;
-using rocksdb::CompressionType;
-using rocksdb::DB;
-using rocksdb::Options;
-using rocksdb::Status;
-using rocksdb::titandb::TitanDB;
-using rocksdb::titandb::TitanOptions;
-
-extern "C" {
-
-struct rocksdb_t {
-  DB* rep;
-};
-struct rocksdb_options_t {
-  Options rep;
-};
-struct rocksdb_cache_t {
-  std::shared_ptr<Cache> rep;
-};
-
-struct titandb_options_t {
-  TitanOptions rep;
-};
-
-static bool SaveError(char** errptr, const Status& s) {
-  assert(errptr != nullptr);
-  if (s.ok()) {
-    return false;
-  } else if (*errptr == nullptr) {
-    *errptr = strdup(s.ToString().c_str());
-  } else {
-    // TODO(sanjay): Merge with existing error?
-    // This is a bug if *errptr is not created by malloc()
-    free(*errptr);
-    *errptr = strdup(s.ToString().c_str());
-  }
-  return true;
-}
-
-rocksdb_t* titandb_open(const titandb_options_t* options, const char* name,
-                        char** errptr) {
-  TitanDB* db;
-  if (SaveError(errptr, TitanDB::Open(options->rep, name, &db))) {
-    return nullptr;
-  }
-  rocksdb_t* result = new rocksdb_t;
-  result->rep = db;
-  return result;
-}
-
-titandb_options_t* titandb_options_create() { return new titandb_options_t; }
-
-void titandb_options_destroy(titandb_options_t* options) { delete options; }
-
-void titandb_options_set_rocksdb(titandb_options_t* options,
-                                 rocksdb_options_t* rocksdb) {
-  options->rep = TitanOptions(rocksdb->rep);
-}
-
-void titandb_options_set_dirname(titandb_options_t* options, const char* name) {
-  options->rep.dirname = name;
-}
-
-void titandb_options_set_min_blob_size(titandb_options_t* options,
-                                       uint64_t size) {
-  options->rep.min_blob_size = size;
-}
-
-void titandb_options_set_blob_file_compression(titandb_options_t* options,
-                                               int compression) {
-  options->rep.blob_file_compression =
-      static_cast<CompressionType>(compression);
-}
-
-void titandb_options_set_blob_cache(titandb_options_t* options,
-                                    rocksdb_cache_t* blob_cache) {
-  if (blob_cache) {
-    options->rep.blob_cache = blob_cache->rep;
-  } else {
-    options->rep.blob_cache.reset();
-  }
-}
-
-void titandb_options_set_disable_background_gc(titandb_options_t* options,
-                                               unsigned char disable) {
-  options->rep.disable_background_gc = disable;
-}
-
-void titandb_options_set_max_gc_batch_size(titandb_options_t* options,
-                                           uint64_t size) {
-  options->rep.max_gc_batch_size = size;
-}
-
-void titandb_options_set_min_gc_batch_size(titandb_options_t* options,
-                                           uint64_t size) {
-  options->rep.min_gc_batch_size = size;
-}
-
-void titandb_options_set_blob_file_discardable_ratio(titandb_options_t* options,
-                                                     float ratio) {
-  options->rep.blob_file_discardable_ratio = ratio;
-}
-
-void titandb_options_set_sample_file_size_ratio(titandb_options_t* options,
-                                                float ratio) {
-  options->rep.sample_file_size_ratio = ratio;
-}
-
-void titandb_options_set_merge_small_file_threshold(titandb_options_t* options,
-                                                    uint64_t size) {
-  options->rep.merge_small_file_threshold = size;
-}
-
-}  // end extern "C"

src/titan_db_test.cc

 #include <inttypes.h>
 #include <options/cf_options.h>
 
-#include "rocksdb/utilities/titandb/db.h"
-#include "utilities/titandb/db_impl.h"
-#include "utilities/titandb/titan_fault_injection_test_env.h"
+#include "titan/db.h"
+#include "db_impl.h"
+#include "titan_fault_injection_test_env.h"
 #include "util/filename.h"
 #include "util/random.h"
 #include "util/testharness.h"

src/util.cc

-#include "utilities/titandb/util.h"
+#include "util.h"
 
 namespace rocksdb {
 namespace titandb {

src/util_test.cc

-#include "utilities/titandb/util.h"
+#include "util.h"
 #include "util/testharness.h"
 
 namespace rocksdb {

src/version.cc

-#include "utilities/titandb/version.h"
-#include "utilities/titandb/version_set.h"
+#include "version.h"
+#include "version_set.h"
 
 namespace rocksdb {
 namespace titandb {

src/version.h

 #pragma once
 
 #include "rocksdb/options.h"
-#include "utilities/titandb/blob_file_cache.h"
-#include "utilities/titandb/blob_format.h"
-#include "utilities/titandb/blob_gc.h"
+#include "blob_file_cache.h"
+#include "blob_format.h"
+#include "blob_gc.h"
 
 namespace rocksdb {
 namespace titandb {

src/version_edit.cc

-#include "utilities/titandb/version_edit.h"
+#include "version_edit.h"
 
 #include "util/coding.h"
 

src/version_edit.h

@@ -3,7 +3,7 @@
 #include <set>
 
 #include "rocksdb/slice.h"
-#include "utilities/titandb/blob_format.h"
+#include "blob_format.h"
 
 namespace rocksdb {
 namespace titandb {

src/version_set.cc

-#include "utilities/titandb/version_set.h"
+#include "version_set.h"
 
 #include <inttypes.h>
 

src/version_set.h

@@ -11,10 +11,10 @@
 #include "rocksdb/options.h"
 #include "rocksdb/status.h"
 #include "util/mutexlock.h"
-#include "utilities/titandb/blob_file_cache.h"
-#include "utilities/titandb/options.h"
-#include "utilities/titandb/version_edit.h"
-#include "utilities/titandb/version.h"
+#include "blob_file_cache.h"
+#include "titan/options.h"
+#include "version_edit.h"
+#include "version.h"
 
 namespace rocksdb {
 namespace titandb {

src/version_test.cc

 #include "util/filename.h"
 #include "util/testharness.h"
-#include "utilities/titandb/testutil.h"
-#include "utilities/titandb/util.h"
-#include "utilities/titandb/version_edit.h"
-#include "utilities/titandb/version_set.h"
+#include "testutil.h"
+#include "util.h"
+#include "version_edit.h"
+#include "version_set.h"
 
 namespace rocksdb {
 namespace titandb {

tools/db_bench.cc

@@ -18,6 +18,6 @@ int main() {
   return 1;
 }
 #else
-#include <rocksdb/db_bench_tool.h>
+#include "db_bench_tool.h"
 int main(int argc, char** argv) { return rocksdb::db_bench_tool(argc, argv); }
 #endif  // GFLAGS

tools/db_bench_tool.cc

@@ -56,7 +56,6 @@
 #include "rocksdb/utilities/optimistic_transaction_db.h"
 #include "rocksdb/utilities/options_util.h"
 #include "rocksdb/utilities/sim_cache.h"
-#include "rocksdb/utilities/titandb/db.h"
 #include "rocksdb/utilities/transaction.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "rocksdb/write_batch.h"
@@ -76,6 +75,8 @@
 #include "utilities/merge_operators/bytesxor.h"
 #include "utilities/persistent_cache/block_cache_tier.h"
 
+#include "titan/db.h"
+
 #ifdef OS_WIN
 #include <io.h>  // open/close
 #endif

tools/titandb_stress.cc

@@ -58,7 +58,6 @@ int main() {
 #include "rocksdb/utilities/checkpoint.h"
 #include "rocksdb/utilities/db_ttl.h"
 #include "rocksdb/utilities/options_util.h"
-#include "rocksdb/utilities/titandb/db.h"
 #include "rocksdb/utilities/transaction.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "rocksdb/write_batch.h"
@@ -78,6 +77,8 @@ int main() {
 
 #include "utilities/merge_operators.h"
 
+#include "titan/db.h"
+
 using GFLAGS_NAMESPACE::ParseCommandLineFlags;
 using GFLAGS_NAMESPACE::RegisterFlagValidator;
 using GFLAGS_NAMESPACE::SetUsageMessage;