diff --git a/.gitignore b/.gitignore
index 781ba3860..95911a8bf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@
 # Automatically generated files
 COPYING
 INSTALL
+include/config.h
 
 # Temporary
 *.swp
@@ -44,3 +45,12 @@ cscope.*
 lcov
 
 CMAKE_BINARY_DIR
+
+# Generated Rust Bindings
+bindings.rs
+
+# Cargo lock file
+Cargo.lock
+
+# Cargo build path
+target
diff --git a/.travis.yml b/.travis.yml
index 41c2b344e..46c0ecd39 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,132 +1,57 @@
 sudo: false
 language: c
+dist: bionic
 
 # using anchor to import sources into linux builds
 addons:
   apt: &apt
     sources:
       - ubuntu-toolchain-r-test
-      - llvm-toolchain-precise-3.6
-      - llvm-toolchain-precise-3.7
-      - llvm-toolchain-precise
 
 # important for allowed-to-fail matching
 # see https://docs.travis-ci.com/user/customizing-the-build#Rows-that-are-Allowed-to-Fail
 env:
-  - ALLOWED_TO_FAIL=0
+  global:
+  - MAKEFLAGS="-j 2"
 
 # travis currently does not support directly setting gcc/clang with versions
 # (e.g. gcc-4.8) as value for the compiler key. So we will have to manually
 # request these packages and use environment varibles to create the matrix.
-#
-# In the case of osx, use brew to install the paritcular versions, instead of
-# specifying with packages.
-matrix:
+jobs:
+  fast_finish: true
   include:
-    # gcc 4.8 on linux
-    - env:
-        - C_COMPILER=gcc-4.8
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - gcc-4.8
-            - libsubunit-dev
+    - name: "gcc-7 on Linux"
+      compiler: gcc
 
-
-    # gcc 4.9 on linux
-    - env:
-        - C_COMPILER=gcc-4.9
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - gcc-4.9
-            - libsubunit-dev
-
-    # gcc 5 on linux
-    - env:
-        - C_COMPILER=gcc-5
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - gcc-5
-            - libsubunit-dev
-
-    # gcc 5 on linux
-    - env:
-        - C_COMPILER=gcc-5
+    - name: "gcc-7 on Linux, Rust enabled"
+      compiler: gcc
+      env:
         - RUST_ENABLED=1
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - gcc-5
-            - libsubunit-dev
-
-    # clang 3.6 on linux
-    - env:
-        - C_COMPILER=clang-3.6
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - clang-3.6
-            - libsubunit-dev
-
-    # clang 3.7 on linux
-    - env:
-        - C_COMPILER=clang-3.7
-      addons:
-        apt:
-          <<: *apt
-          packages:
-            - clang-3.7
-            - libsubunit-dev
 
-    ## gcc 4.8 on osx
-    #- os: osx
-    #  env: FORMULA=gcc48 COMPILER=gcc C_COMPILER=gcc-4.8
-    #
-    ## gcc 4.9 on osx
-    #- os: osx
-    #  env: FORMULA=gcc49 COMPILER=gcc C_COMPILER=gcc-4.9
-    #
-    ## gcc 5 on osx
-    #- os: osx
-    #  env: FORMULA=gcc5 COMPILER=gcc C_COMPILER=gcc-5
+    - name: "cargo build"
+      language: rust
+      script:
+        - ./ci/cargo.sh
 
-    # OSX 10.13
-    # Apple LLVM version 9.1.0 (clang-902.0.39.2)
-    # Target: x86_64-apple-darwin17.6.0
     - os: osx
-      osx_image: xcode9.4
-      env:
-        - C_COMPILER=clang
-        - ALLOWED_TO_FAIL=1
+      osx_image: xcode11.4
+      compiler: clang
 
-    # OSX 10.12
-    # Apple LLVM version 9.0.0 (clang-900.0.39.2)
-    # Target: x86_64-apple-darwin16.7.0
     - os: osx
-      osx_image: xcode9.2
-      env:
-        - C_COMPILER=clang
-        - ALLOWED_TO_FAIL=1
+      osx_image: xcode11.4
+      language: rust
+      script:
+        - ./ci/cargo.sh
 
   allow_failures:
     - os: osx
-      osx_image: xcode9.4
-      env:
-        - C_COMPILER=clang
-        - ALLOWED_TO_FAIL=1
-
+      osx_image: xcode11.4
+      compiler: clang
     - os: osx
-      osx_image: xcode9.2
-      env:
-        - C_COMPILER=clang
-        - ALLOWED_TO_FAIL=1
+      osx_image: xcode11.4
+      language: rust
+      script:
+        - ./ci/cargo.sh
 
 before_install:
   - ./ci/before-install.sh
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2d2a2c05a..f17e543cc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,8 @@
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 3.0)
 project(ccommon C)
 
-enable_testing()
+# Uncomment the following to output dependency graph debugging messages
+# set_property(GLOBAL PROPERTY GLOBAL_DEPENDS_DEBUG_MODE 1)
 
 ###################
 # detect platform #
@@ -36,8 +37,8 @@ endif()
 # config.h.in has to include entries set/tested here for them to have effect
 
 # version info
-set(${PROJECT_NAME}_VERSION_MAJOR 1)
-set(${PROJECT_NAME}_VERSION_MINOR 2)
+set(${PROJECT_NAME}_VERSION_MAJOR 2)
+set(${PROJECT_NAME}_VERSION_MINOR 1)
 set(${PROJECT_NAME}_VERSION_PATCH 0)
 set(${PROJECT_NAME}_VERSION
    ${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_PATCH}
@@ -51,60 +52,35 @@ option(HAVE_ASSERT_LOG "assert_log enabled by default" ON)
 option(HAVE_ASSERT_PANIC "assert_panic disabled by default" OFF)
 option(HAVE_LOGGING "logging enabled by default" ON)
 option(HAVE_STATS "stats enabled by default" ON)
+option(HAVE_TEST "test built by default" ON)
 option(HAVE_DEBUG_MM "debugging oriented memory management disabled by default" OFF)
-option(COVERAGE "code coverage" OFF)
+option(HAVE_COVERAGE "code coverage" OFF)
 option(HAVE_RUST "rust bindings not built by default" OFF)
+option(HAVE_ITT_INSTRUMENTATION "instrument code with ITT API" OFF)
+
+option(FORCE_CHECK_BUILD "Force building check with ci/install-check.sh" OFF)
 
 if(HAVE_RUST)
     option(RUST_VERBOSE_BUILD "pass -vv to cargo compilation" OFF)
 endif()
 
-if(BUILD_AND_INSTALL_CHECK)
-    # (simms) What follows is a crime against build systems as we run the build/install
-    # for the check library up front, during the planning phase.
-
-    set(LIBCHECK_PREFIX "${CMAKE_BINARY_DIR}/check")
-
-    # check for a local install of check
-    if(NOT EXISTS "${LIBCHECK_PREFIX}")
-        # (simms) This is terrible and I did it this way to ensure this gets built
-        # before the rest of the 'check' tests run. This should be rewritten so that
-        # the other dependencies know that there's a target that can build check
-        execute_process(
-            COMMAND "bash" "${PROJECT_SOURCE_DIR}/ci/install-check.sh" "${LIBCHECK_PREFIX}"
-            TIMEOUT 300  # if this doesn't build in 5 minutes something is hosed
-        )
-    endif()
-
-    set(CHECK_ROOT_DIR "${LIBCHECK_PREFIX}")
-    set(CMAKE_REQUIRED_INCLUDES "${CHECK_ROOT_DIR}/include")    # these make check link correctly in ccommon and pelikan
-    set(CMAKE_REQUIRED_LIBRARIES "${CHECK_ROOT_DIR}/lib")
-endif()
-
 include(CheckIncludeFiles)
 if(OS_PLATFORM STREQUAL "OS_LINUX")
     check_include_files(linux/time64.h HAVE_TIME64)
 endif()
 
-include(CheckIncludeFiles)
-if(OperatingSystem STREQUAL "OS_LINUX")
-    check_include_files(linux/time64.h HAVE_TIME64)
-endif()
-
 include(CheckSymbolExists)
 check_symbol_exists(sys_signame signal.h HAVE_SIGNAME)
 
 include(CheckFunctionExists)
 check_function_exists(backtrace HAVE_BACKTRACE)
-
-include(TestBigEndian)
-test_big_endian(HAVE_BIG_ENDIAN)
+check_function_exists(accept4 HAVE_ACCEPT4)
 
 # how to use config.h.in to generate config.h
 # this has to be set _after_ the above checks
 configure_file(
   "${PROJECT_SOURCE_DIR}/config.h.in"
-  "${PROJECT_BINARY_DIR}/config.h")
+  "${PROJECT_SOURCE_DIR}/include/config.h")
 
 
 ##########################
@@ -112,46 +88,98 @@ configure_file(
 ##########################
 
 # set compiler flags
-# string concat is easier in 3.0, but older versions don't have the concat subcommand
-# so we are using list as input until we move to new version
-# TODO add build types
+
 add_definitions(-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64)
+
+# Set a default build type (Release) if none was specified
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0")
+else()
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
+endif()
+
 set(CMAKE_MACOSX_RPATH 1)
-set(CFLAGS_LIST
+string(CONCAT CFLAGS
     "-std=c11 "
-    "-ggdb3 -O2 "
+    "-ggdb3 "
     "-Wall "
     "-Wmissing-prototypes -Wmissing-declarations -Wredundant-decls "
     "-Wunused-function -Wunused-value -Wunused-variable "
     "-fstrict-aliasing ")
-string(REPLACE "" "" CFLAGS ${CFLAGS_LIST})
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  ${CFLAGS}")
 
 if(CMAKE_COMPILER_IS_GNUCC)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,--no-as-needed -ldl -pthread -fPIC")
 endif()
 
-if (COVERAGE)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -Wall -W -fprofile-arcs -ftest-coverage")
-endif(COVERAGE)
-
-# test dependencies
 include(FindPackageHandleStandardArgs)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 
-find_package(Check)
-if(NOT CHECK_FOUND)
-    message(WARNING "Check is required to build and run tests")
-endif(NOT CHECK_FOUND)
-if(CHECK_FOUND)
-    check_symbol_exists(ck_assert_int_eq check.h CHECK_WORKING)
-    if(NOT CHECK_WORKING)
-        message(WARNING "Check version too old to build tests")
-    endif(NOT CHECK_WORKING)
-endif(CHECK_FOUND)
+# test dependencies
+if (HAVE_TEST)
+    enable_testing()
+    # first we try default ways of finding gmodules
+    find_package(CHECK)
+    if(CHECK_FOUND)
+        check_symbol_exists(ck_assert_int_eq check.h CHECK_WORKING)
+    endif(CHECK_FOUND)
+    # if we don't have a working version of check, build it
+    if(NOT CHECK_WORKING OR FORCE_CHECK_BUILD)
+        set(LIBCHECK_PREFIX "${CMAKE_BINARY_DIR}/check")
+        execute_process(
+            COMMAND "bash" "${PROJECT_SOURCE_DIR}/ci/install-check.sh" "${LIBCHECK_PREFIX}"
+            TIMEOUT 300  # if this doesn't build in 5 minutes something is hosed
+            RESULT_VARIABLE LIBCHECK_RETCODE
+        )
+        if(LIBCHECK_RETCODE) # non-zero means error
+            message(STATUS "build libcheck failed, return code: " ${LIBCHECK_RETCODE})
+        else(LIBCHECK_RETCODE)
+            # use locally built libcheck
+            set(CHECK_ROOT_DIR "${LIBCHECK_PREFIX}")
+            find_package(CHECK)
+        endif(LIBCHECK_RETCODE)
+    endif(NOT CHECK_WORKING OR FORCE_CHECK_BUILD)
+
+    # use fluxcapacitor to mock time
+    if(OS_PLATFORM STREQUAL "OS_LINUX")
+        set(FLUXCAP_PREFIX "${CMAKE_BINARY_DIR}/fluxcapacitor")
+        execute_process(
+            COMMAND "bash" "${PROJECT_SOURCE_DIR}/ci/install-fluxcapacitor.sh" "${FLUXCAP_PREFIX}"
+            TIMEOUT 60  # if this doesn't build in 60 seconds something is hosed
+            RESULT_VARIABLE FLUXCAP_RETCODE
+        )
+        if(FLUXCAP_RETCODE) # non-zero means error
+            message(STATUS "build fluxcapacitor failed, return code: " ${FLUXCAP_RETCODE})
+        else(FLUXCAP_RETCODE)
+            set(FLUXCAP_BINARY "${FLUXCAP_PREFIX}/fluxcapacitor")
+            message(STATUS "fluxcapacitor available at: " ${FLUXCAP_BINARY})
+        endif(FLUXCAP_RETCODE)
+    endif(OS_PLATFORM STREQUAL "OS_LINUX")
+endif(HAVE_TEST)
+
+if (HAVE_ITT_INSTRUMENTATION)
+    if(PKG_CONFIG_FOUND)
+        pkg_check_modules(ITTNOTIFY REQUIRED ittnotify>=1.0)
+    else()
+        find_package(ITTNOTIFY REQUIRED 1.0)
+    endif()
+    include_directories(${ITTNOTIFY_INCLUDE_DIRS})
+    link_directories(${ITTNOTIFY_LIBRARY_DIRS})
+    link_libraries(${ITTNOTIFY_LIBRARIES})
+endif(HAVE_ITT_INSTRUMENTATION)
 
 find_package(Threads)
 
+if (HAVE_COVERAGE)
+    if(NOT ${CMAKE_BUILD_TYPE} MATCHES Debug)
+        message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading" )
+    endif()
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+endif(HAVE_COVERAGE)
 
 # where to find include files
 include_directories(
@@ -159,36 +187,75 @@ include_directories(
     "${PROJECT_BINARY_DIR}"
     "include")
 
-if(HAVE_RUST)
-    enable_language(Rust)
-    include(CMakeCargo)
-    add_subdirectory(rust)
-    set(CMAKE_C_FLAGS  "${CMAKE_C_FLAGS} -DHAVE_RUST=1")
-endif()
-
-
 ###################
 # things to build #
 ###################
 
 add_subdirectory(src)
-if(CHECK_WORKING)
-    include_directories(${include_directories} "${CHECK_INCLUDES}")
+
+if(HAVE_TEST)
+    include_directories(${include_directories} ${CHECK_INCLUDES})
     add_subdirectory(test)
-endif(CHECK_WORKING)
+endif(HAVE_TEST)
+
+if(HAVE_RUST)
+    include(CMakeCargo)
+    add_subdirectory(rust)
+
+    if (${CMAKE_VERSION} VERSION_LESS "3.13.0")
+        # CMakeCargo requires the use of some newer features of cmake
+        # for changes to dependant libraries to cause a rebuild. This
+        # will never break the build, it is just annoying for development.
+        # Leave a warning here, but don't break the build for older cmake
+        # versions.
+        message(
+            WARNING
+            "Rust targets don't properly pick up changes to dependencies in cmake version <= 3.13"
+        )
+    endif()
+endif()
 
 ###################
 # print a summary #
 ###################
 
+message(STATUS "<<++=====------------------\\/------------------=====++>>")
+message(STATUS "<<++                 ccommon summary                 ++>>")
+message(STATUS "<<++=====------------------/\\------------------=====++>>")
+message(STATUS "=============CMake related=============")
+message(STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE})
 message(STATUS "PLATFORM: " ${OS_PLATFORM})
-
 message(STATUS "CPPFLAGS: " ${CMAKE_CPP_FLAGS})
 message(STATUS "CFLAGS: " ${CMAKE_C_FLAGS})
+message(STATUS "=======================================")
 
+message(STATUS "=======Status of system features=======")
 message(STATUS "HAVE_SIGNAME: " ${HAVE_SIGNAME})
-
 message(STATUS "HAVE_BACKTRACE: " ${HAVE_BACKTRACE})
-message(STATUS "HAVE_BIG_ENDIAN: " ${HAVE_BIG_ENDIAN})
-
-message(STATUS "CHECK_WORKING: " ${CHECK_WORKING})
+message(STATUS "HAVE_ACCEPT4: " ${HAVE_ACCEPT4})
+if(OS_PLATFORM STREQUAL "OS_LINUX")
+    message(STATUS "HAVE_TIME64: " ${HAVE_TIME64})
+endif()
+message(STATUS "=======================================")
+
+message(STATUS "======Status of optional features======")
+message(STATUS "HAVE_RUST: " ${HAVE_RUST})
+message(STATUS "HAVE_ASSERT_LOG: " ${HAVE_ASSERT_LOG})
+message(STATUS "HAVE_ASSERT_PANIC: " ${HAVE_ASSERT_PANIC})
+message(STATUS "HAVE_LOGGING: " ${HAVE_LOGGING})
+message(STATUS "HAVE_STATS: " ${HAVE_STATS})
+message(STATUS "HAVE_ITT_INSTRUMENTATION: " ${HAVE_ITT_INSTRUMENTATION})
+message(STATUS "HAVE_DEBUG_MM: " ${HAVE_DEBUG_MM})
+message(STATUS "HAVE_TEST: " ${HAVE_TEST})
+message(STATUS "HAVE_COVERAGE: " ${HAVE_COVERAGE})
+message(STATUS "=======================================")
+
+
+if(DUMP_ALL)
+    message(STATUS "<<++=====------------------\\/------------------=====++>>")
+    get_cmake_property(_variableNames VARIABLES)
+    foreach (_variableName ${_variableNames})
+        message(STATUS "${_variableName}=${${_variableName}}")
+    endforeach()
+    message(STATUS "<<++=====------------------/\\------------------=====++>>")
+endif()
diff --git a/LICENSE b/LICENSE
index ecc06d346..5c3aef4f8 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright 2013-2015 Twitter, Inc
+Copyright 2013-2018 Twitter, Inc
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
diff --git a/NOTICE b/NOTICE
index 2b7bb058e..e0672064d 100644
--- a/NOTICE
+++ b/NOTICE
@@ -22,3 +22,5 @@
  * Boston, MA 02111-1307, USA.
  */
 
+We use the CMakeRust project (https://github.com/Devolutions/CMakeRust) under
+the Apache 2.0 License.
diff --git a/ci/before-install.sh b/ci/before-install.sh
index cff9327c3..b5f49421a 100755
--- a/ci/before-install.sh
+++ b/ci/before-install.sh
@@ -11,21 +11,6 @@ trap cleanup EXIT
 
 TOPLEVEL="$(git -C "$(cd "$(dirname "$0")" >/dev/null || exit 1; pwd)" rev-parse --show-toplevel)" || die 'failed to find TOPLEVEL'
 
-# for osx: 0. update brew; 1. install cmake if missing; 2. (gcc) unlink pre-installed gcc; 3. (gcc) install desired version of gcc
-
-if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-  brew update &>/dev/null
-  brew install cmake || true            # xcode 8.1 is missing cmake
-
-  if [[ "$C_COMPILER" =~ ^gcc && -n "${FORMULA:-}" ]]; then
-    brew unlink gcc || true
-    brew unlink "$FORMULA" || true
-    brew install "$FORMULA"
-  fi
-fi
-
-export CC="$C_COMPILER"
-
 if [[ -n "${RUST_ENABLED:-}" ]]; then
   curl https://sh.rustup.rs -sSf | sh -s -- -y
 fi
diff --git a/ci/cargo.sh b/ci/cargo.sh
new file mode 100755
index 000000000..8a8c25725
--- /dev/null
+++ b/ci/cargo.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+set -uo pipefail
+IFS=$'\n\t'
+
+# Cargo currently does not allow nested workspaces. Since this repo is vendored
+# into github.com/twitter/pelikan which is itself a workspace, we cannot commit
+# a workspace manifest for this repository. Cargo tracking issue: 
+# https://github.com/rust-lang/cargo/issues/5042
+
+# As a workaround, we can construct a workspace manifest before running the
+# build. This allows the crates within this repo to share build artifacts.
+
+###
+# Create workspace manifest
+###
+
+cat > Cargo.toml <<HEADER
+[workspace]
+members = [
+HEADER
+
+for CRATE_MANIFEST in `find rust -type f -name "Cargo.toml"`; do
+  CRATE_ROOT=`dirname ${CRATE_MANIFEST}`
+  echo "\"${CRATE_ROOT}\"," >> Cargo.toml
+done
+
+cat >> Cargo.toml <<FOOTER
+]
+
+[profile.bench]
+debug = true
+lto = true
+codegen-units = 1
+
+[profile.release]
+debug = true
+lto = true
+codegen-units = 1
+FOOTER
+
+###
+# Run cargo build/test for the workspace
+###
+
+cargo build
+cargo test
+cargo build --release
+cargo test --release
+
+###
+# Remove workspace manifest
+###
+rm Cargo.toml
diff --git a/ci/install-check.sh b/ci/install-check.sh
index 628d6d229..edddb140e 100755
--- a/ci/install-check.sh
+++ b/ci/install-check.sh
@@ -17,18 +17,40 @@ TEMP="$(mktemp -d -t TEMP.XXXXXXX)" || die "failed to make tmpdir"
 cleanup() { [[ -n "${TEMP:-}" ]] && rm -rf "${TEMP}"; }
 trap cleanup EXIT
 
-TOPLEVEL="$(git -C "$(cd "$(dirname "$0")" >/dev/null || exit 1; pwd)" rev-parse --show-toplevel)" || die 'failed to find TOPLEVEL'
+realpath() { python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$1"; }
 
-CHECK_VERSION=0.12.0
+TOPLEVEL="$(cd "$(dirname "$(realpath "$0" >/dev/null || exit 1)")" && git rev-parse --show-toplevel)" || die 'failed to find TOPLEVEL'
+
+
+CHECK_VERSION="0.14.0"
 CHECK_TARBALL="check-${CHECK_VERSION}.tar.gz"
 CHECK_DIR="check-${CHECK_VERSION}"
+CHECK_LOG="build-check.log"
+
+echo "building and installing check" >&2
 
 (
   cd "$TEMP" &&
     wget "https://github.com/libcheck/check/releases/download/${CHECK_VERSION}/${CHECK_TARBALL}" &&
-    tar xvfz "${CHECK_TARBALL}" &&
+    tar xfz "${CHECK_TARBALL}" &&
     cd "${CHECK_DIR}" &&
-    ./configure --prefix="$CHECK_PREFIX" &&
-    make &&
+    mkdir build &&
+    cd build &&
+    cmake -DCMAKE_INSTALL_PREFIX="${CHECK_PREFIX}" .. &&
+    make -j &&
     make install
-) || die "check build failed"
+) >$TEMP/${CHECK_LOG} 2>&1
+
+RESULT=$?
+if [[ $RESULT -ne 0 ]]; then
+  cat >&2 <<EOS
+check build failed! log below:
+
+EOS
+
+  cat $TEMP/${CHECK_LOG}
+else
+  echo "Success!" >&2
+fi
+
+exit $RESULT
diff --git a/ci/install-fluxcapacitor.sh b/ci/install-fluxcapacitor.sh
new file mode 100755
index 000000000..643350f63
--- /dev/null
+++ b/ci/install-fluxcapacitor.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+set -euo pipefail
+IFS=$'\n\t'
+
+die() { echo "fatal: $*" >&2; exit 1; }
+
+if [[ $# -lt 1 ]]; then
+  echo "Usage: $0 fluxcap-install-path"
+  exit 1
+fi
+
+FLUXCAP_PREFIX="$1"
+shift
+
+TEMP="$(mktemp -d -t TEMP.XXXXXXX)" || die "failed to make tmpdir"
+cleanup() { [[ -n "${TEMP:-}" ]] && rm -rf "${TEMP}"; }
+trap cleanup EXIT
+
+realpath() { python3 -c "import os,sys; print(os.path.realpath(sys.argv[1]))" "$1"; }
+
+TOPLEVEL="$(cd "$(dirname "$(realpath "$0" >/dev/null || exit 1)")" && git rev-parse --show-toplevel)" || die 'failed to find TOPLEVEL'
+
+
+FLUXCAP_VERSION=0.1
+FLUXCAP_TARBALL="${FLUXCAP_VERSION}.tar.gz"
+FLUXCAP_DIR="fluxcapacitor-${FLUXCAP_VERSION}"
+FLUXCAP_LOG="build-fluxcapacitor.log"
+
+echo "building fluxcapacitor" >&2
+
+(
+  cd "$TEMP" &&
+    wget "https://github.com/thinkingfish/fluxcapacitor/archive/${FLUXCAP_TARBALL}" &&
+    tar xfz "${FLUXCAP_TARBALL}" &&
+    pwd &&
+    ls . &&
+    cd "${FLUXCAP_DIR}" &&
+    make build
+) >$TEMP/${FLUXCAP_LOG} 2>&1
+
+RESULT=$?
+if [[ $RESULT -ne 0 ]]; then
+  cat >&2 <<EOS
+fluxcapacitor build failed! log below:
+
+EOS
+
+  cat $TEMP/${FLUXCAP_LOG}
+else
+  rsync -a "$TEMP/${FLUXCAP_DIR}/fluxcapacitor" ${FLUXCAP_PREFIX}/
+  echo "Success!" >&2
+fi
+
+exit $RESULT
diff --git a/ci/local-run.sh b/ci/local-run.sh
new file mode 100755
index 000000000..ecc90c3ec
--- /dev/null
+++ b/ci/local-run.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+## This file is potentially useful for doing a clean environment build on MacOS ##
+## This is my personal way of running the build, YMMV - jsimms                  ##
+
+set -euo pipefail
+IFS=$'\n\t'
+
+die() { echo "fatal: $*" >&2; exit 1; }
+
+TOPLEVEL=$(git -C "$(cd "$(dirname "$0")" >/dev/null || exit 1; pwd)" rev-parse --show-toplevel) || die "TOPLEVEL fail"
+
+cd "$TOPLEVEL"
+
+TEMP="$(mktemp -d -t TEMP.XXXXXXX)" || die "failed to make tmpdir"
+cleanup() { [[ -n "${TEMP:-}" ]] && rm -rf "${TEMP}"; }
+trap cleanup EXIT
+
+BUILD_PATH=(
+  "$HOME/.cargo/bin"
+  "/usr/local/bin"
+  "/usr/local/sbin"
+  "/usr/bin"
+  "/usr/sbin"
+  "/bin"
+  "/sbin"
+  "/opt/X11/bin"
+  "/usr/X11R6/bin"
+)
+
+PATH=$(echo "${BUILD_PATH[@]}"|tr ' ' ':')
+
+cat >&2 <<EOS
+CC=${CC:-}
+CFLAGS=${CFLAGS:-}
+LDFLAGS=${LDFLAGS:-}
+PATH=${PATH:-}
+EOS
+
+CMAKEFLAGS=(
+  -DHAVE_RUST=yes
+  -DRUST_VERBOSE_BUILD=yes
+  -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON
+)
+
+BUILD_DIR="${BUILD_DIR:-$TEMP}"
+
+mkdir -p "$BUILD_DIR" && (
+  cd "$BUILD_DIR" &&
+  cmake "${CMAKEFLAGS[@]}" "$TOPLEVEL" &&
+  make all &&
+  make check &&
+  cd rust &&
+  cargo test
+)
diff --git a/ci/run.sh b/ci/run.sh
index 588bbc0b2..6e99dc3c3 100755
--- a/ci/run.sh
+++ b/ci/run.sh
@@ -9,7 +9,6 @@ export PATH=$HOME/.cargo/bin:$PATH
 
 cmake_cmd=(
   cmake
-  -DBUILD_AND_INSTALL_CHECK=yes
 )
 
 if [[ -n "${RUST_ENABLED:-}" ]]; then
@@ -17,11 +16,12 @@ if [[ -n "${RUST_ENABLED:-}" ]]; then
 fi
 
 export RUST_BACKTRACE=full
+export CTEST_OUTPUT_ON_FAILURE=1
 
-mkdir -p _build && ( cd _build && "${cmake_cmd[@]}" .. && make -j && make check )
+mkdir -p _build && ( cd _build && "${cmake_cmd[@]}" .. && make && make test )
 RESULT=$?
 
-egrep -r ":F:|:E:" . |grep -v 'Binary file' || true
+egrep -r ":F:|:E:" _build/test |grep -v 'Binary file' || true
 
 
 if [[ $RESULT -ne 0 ]]; then
diff --git a/cmake/CMakeCargo.cmake b/cmake/CMakeCargo.cmake
index 81920f8e7..7d392b4aa 100644
--- a/cmake/CMakeCargo.cmake
+++ b/cmake/CMakeCargo.cmake
@@ -1,101 +1,397 @@
-function(cargo_set_lib_target LIB_NAME)
+# ccommon - a cache common library.
+# Copyright (C) 2019 Twitter, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Hack to ensure we have the directory of this cmake file when
+# the functions contained within are called.
+set(FILE_LIST_DIR ${CMAKE_CURRENT_LIST_DIR} CACHE INTERNAL "")
+
+# Get the target that we want to pass to cargo
+function(cargo_build_private_get_target TARGET_VAR)
     if(WIN32)
         if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-            set(LIB_TARGET "x86_64-pc-windows-msvc" PARENT_SCOPE)
+            set(LIB_TARGET "x86_64-pc-windows-msvc")
         else()
-            set(LIB_TARGET "i686-pc-windows-msvc" PARENT_SCOPE)
+            set(LIB_TARGET "i686-pc-windows-msvc")
         endif()
     elseif(ANDROID)
         if(ANDROID_SYSROOT_ABI STREQUAL "x86")
-            set(LIB_TARGET "i686-linux-android" PARENT_SCOPE)
+            set(LIB_TARGET "i686-linux-android")
         elseif(ANDROID_SYSROOT_ABI STREQUAL "x86_64")
-            set(LIB_TARGET "x86_64-linux-android" PARENT_SCOPE)
+            set(LIB_TARGET "x86_64-linux-android")
         elseif(ANDROID_SYSROOT_ABI STREQUAL "arm")
-            set(LIB_TARGET "arm-linux-androideabi" PARENT_SCOPE)
+            set(LIB_TARGET "arm-linux-androideabi")
         elseif(ANDROID_SYSROOT_ABI STREQUAL "arm64")
-            set(LIB_TARGET "aarch64-linux-android" PARENT_SCOPE)
+            set(LIB_TARGET "aarch64-linux-android")
         endif()
     elseif(IOS)
-        set(LIB_TARGET "universal" PARENT_SCOPE)
+        set(LIB_TARGET "universal")
     elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
-        set(LIB_TARGET "x86_64-apple-darwin" PARENT_SCOPE)
+        set(LIB_TARGET "x86_64-apple-darwin")
     else()
-        if(RUST_USE_MUSL)
-            set(RUST_LIBC_NAME "musl")
-        else()
-            set(RUST_LIBC_NAME "gnu")
-        endif()
-
         if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-            set(LIB_TARGET "x86_64-unknown-linux-${RUST_LIBC_NAME}" PARENT_SCOPE)
+            set(LIB_TARGET "x86_64-unknown-linux-gnu")
         else()
-            set(LIB_TARGET "i686-unknown-linux-${RUST_LIBC_NAME}" PARENT_SCOPE)
+            set(LIB_TARGET "i686-unknown-linux-gnu")
         endif()
     endif()
+
+    set(${TARGET_VAR} ${LIB_TARGET} PARENT_SCOPE)
+endfunction()
+
+# Get whether to build in release or debug mode
+function(cargo_build_private_get_build_type TARGET_VAR)
+    if(NOT CMAKE_BUILD_TYPE)
+        set(${TARGET_VAR} "debug" PARENT_SCOPE)
+    elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
+        set(${TARGET_VAR} "release" PARENT_SCOPE)
+    else()
+        set(${TARGET_VAR} "debug" PARENT_SCOPE)
+    endif()
 endfunction()
 
+# Create a set of targets to invoke cargo and pass in
+# the required linker flags. This is meant to be run
+# in the same directory as the Cargo.toml file for the
+# library.
+#
+# In all cases, the target can be used as if it was defined
+# through the add_executable or add_binary. In addition,
+# library dependencies will be properly passed through.
+#
+# Arguments:
+#   NAME <lib-name>
+#       The library package name as specified in Cargo.toml.
+#       This argument is required.
+#   TARGET_DIR <dir>
+#       Overrides the default directory for the cargo target
+#       directory which is ${CMAKE_BINARY_DIR}/target.
+#   BIN
+#       Indicates that this crate generated a binary and to
+#       expose that binary file as a target.
+#   STATIC
+#       Indicates this target generates a static library that
+#       can be consumed by other cmake targets.
+#   NO_TEST
+#       Disables generation of the test target.
+#
+# Notes:
+#   - If neither BIN or STATIC is defined then it is assumed
+#     that the target exports no artifacts (i.e. it is only used
+#     by other rust targets within the build)
+#   - Build and exported are currently mutually exclusive. If you
+#     want to have multiple targets like this then call cargo_build
+#     multiple times.
+#
+# Additional Things:
+#   - This also sets up the required cmake properties to delete the
+#     target directory when `make clean` or equivalent is run.
+#
+# How it Works:
+#   In general, cmake has a hard time integrating with external build
+#   systems within the same directory. However, cmake has extensive
+#   support for custom linkers and also allows you to define interface
+#   libraries when no artifact is created. Together, we can use these
+#   to trick cmake into thinking it is building the executable while
+#   actually using cargo to build them. This means that things like
+#   linker flags and dependencies should mostly "just work" (hopefully).
+#
+#   What we have to do depends on what type of library we are compiling:
+#       - For pure rust libraries that don't export any C API, we define
+#         an interface library. This means that any linker flags are
+#         properly passed on to downstream dependencies. In addition, we
+#         define a custom target so the library is built.
+#       - For static libraries, we define a library that's built using a
+#         custom linker language. The custom linker command is really just
+#         a `cargo build` in disguise, but one that passes the correct
+#         flags in.
+#       - For binaries, we define an executable target also using a custom
+#         linker language similar to a static library.
+#
+#   To pass the proper linker flags to the rust process, we have a special
+#   target <NAME>.linkflags.txt that echoes the linker flags into a known
+#   file. These are then picked up by the import-link-flags crate which
+#   uses a build script to pass them to rustc.
 function(cargo_build)
-    cmake_parse_arguments(CARGO "" "NAME" "" ${ARGN})
+    cmake_parse_arguments(
+        CARGO
+        "BIN;STATIC;NO_TEST"
+        "NAME;TARGET_DIR;COPY_TO"
+        ""
+        ${ARGN}
+    )
+
     string(REPLACE "-" "_" LIB_NAME ${CARGO_NAME})
+    
+    if(NOT (DEFINED CARGO_TARGET_DIR))
+        if ($ENV{CI})
+            set(CARGO_TARGET_DIR ${CMAKE_BINARY_DIR}/target)
+        else()
+            set(CARGO_TARGET_DIR ${CMAKE_CURRENT_BINARY_DIR}/target)
+        endif()
+    endif()
 
-    get_filename_component(CARGO_TARGET_DIR "${CMAKE_CURRENT_BINARY_DIR}" ABSOLUTE)
+    if(CARGO_BIN AND CARGO_STATIC)
+        message(
+            FATAL_ERROR
+            "Cannot create a cargo target that has "
+            "both a binary and a static library. Use multiple "
+            "targets instead."
+        )
+    endif()
 
-    cargo_set_lib_target(LIB_NAME)
+    cargo_build_private_get_target(CRATE_TARGET)
+    cargo_build_private_get_build_type(CRATE_BUILD_TYPE)
 
-    if(NOT CMAKE_BUILD_TYPE)
-        set(LIB_BUILD_TYPE "debug")
-    elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
-        set(LIB_BUILD_TYPE "release")
+    # The CONFIGURE_DEPENDS flag will rerun the glob at build time if the
+    # the build system supports it.
+    file(
+        GLOB_RECURSE CRATE_SOURCES
+        CONFIGURE_DEPENDS "*.rs"
+    )
+
+    list(APPEND CRATE_SOURCES Cargo.toml)
+
+    # Clean the target directory when make clean is run
+    set_directory_properties(PROPERTIES
+        ADDITIONAL_CLEAN_FILES
+        ${CARGO_TARGET_DIR}
+    )
+
+    if(CARGO_BIN OR CARGO_STATIC)
+        set(LINK_FLAGS_FILE $<TARGET_FILE:${CARGO_NAME}>.linkflags.txt)
     else()
-        set(LIB_BUILD_TYPE "debug")
+        set(LINK_FLAGS_FILE $<TARGET_FILE:${CARGO_NAME}-link-export>)
     endif()
 
-    set(SHARED_LIB_FNAME "${CMAKE_SHARED_LIBRARY_PREFIX}${LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}")
-    set(STATIC_LIB_FNAME "${CMAKE_STATIC_LIBRARY_PREFIX}${LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}")
-
-    set(LIB_BASE_DIR "${CARGO_TARGET_DIR}/${LIB_TARGET}/${LIB_BUILD_TYPE}")
+    set(FORWARDED_VARS
+        # So that internal invocations of cmake are consistent
+        "CMAKE=${CMAKE_COMMAND}"
+        # So that build scripts can configure themselves based
+        # on whether cmake is driving the build or not
+        "CCOMMON_CMAKE_IS_DRIVING_BUILD=1"
+        # Needed to configure the correct target directory
+        "CARGO_TARGET_DIR=${CARGO_TARGET_DIR}"
+        # Needed for build scripts
+        "CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR}"
+    )
 
-    get_filename_component(SHARED_LIB_FILE "${LIB_BASE_DIR}/${SHARED_LIB_FNAME}" ABSOLUTE)
-    get_filename_component(STATIC_LIB_FILE "${LIB_BASE_DIR}/${STATIC_LIB_FNAME}" ABSOLUTE)
+    if(CARGO_BIN)
+        set(OUTPUT_FILE_NAME ${LIB_NAME}${CMAKE_EXECUTABLE_SUFFIX})
+        set(OUTPUT_FILE ${CARGO_TARGET_DIR}/${CRATE_TARGET}/${CRATE_BUILD_TYPE}/${OUTPUT_FILE_NAME})
+    elseif(CARGO_STATIC)
+        set(OUTPUT_FILE_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}${LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX})
+        set(OUTPUT_FILE ${CARGO_TARGET_DIR}/${CRATE_TARGET}/${CRATE_BUILD_TYPE}/${OUTPUT_FILE_NAME})
+    endif()
 
     if(IOS)
-        set(CARGO_ARGS "lipo")
-    else()
-        set(CARGO_ARGS "build")
-        list(APPEND CARGO_ARGS "--target" ${LIB_TARGET})
+        # Since we're going through cargo rustc to pass linker flags
+        # this won't work. The previous build script used cargo lipo
+        # here. However, the likelyhood of someone wanting to use
+        # a library for cache servers on IOS is low at this time so
+        # this is OK.
+        message(FATAL_ERROR "Compiling for IOS is not supported")
     endif()
 
-    if(RUST_VERBOSE_BUILD)
-        list(APPEND CARGO_ARGS "-vv")
-    endif()
+    # Arguments to cargo
+    set(CRATE_ARGS "")
+    list(APPEND CRATE_ARGS "--target" ${CRATE_TARGET})
 
-    if(${LIB_BUILD_TYPE} STREQUAL "release")
-        list(APPEND CARGO_ARGS "--release")
+    if(${CRATE_BUILD_TYPE} STREQUAL "release")
+        list(APPEND CRATE_ARGS "--release")
     endif()
 
-    file(GLOB_RECURSE LIB_SOURCES "*.rs")
+    # Convert CRATE_ARGS from a list to a string
+    string(REPLACE ";" " " CRATE_ARGS_STR "${CRATE_ARGS}")
 
-    set(CARGO_ENV_COMMAND ${CMAKE_COMMAND} -E env "CARGO_TARGET_DIR=${CARGO_TARGET_DIR}")
+    set(LINK_FLAGS_FILE "${CMAKE_CURRENT_BINARY_DIR}/${CARGO_NAME}.linkflags.txt")
 
-    add_custom_command(
-        OUTPUT ${STATIC_LIB_FILE}
-        COMMAND ${CARGO_ENV_COMMAND} ${CARGO_EXECUTABLE} ARGS ${CARGO_ARGS}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        DEPENDS ${LIB_SOURCES}
-        COMMENT "running cargo")
-    add_custom_target(${CARGO_NAME}_static_target ALL DEPENDS ${STATIC_LIB_FILE})
-    add_library(${CARGO_NAME}_static STATIC IMPORTED GLOBAL)
-    add_dependencies(${CARGO_NAME}_static ${CARGO_NAME}_static_target)
-    set_target_properties(${CARGO_NAME}_static PROPERTIES IMPORTED_LOCATION ${STATIC_LIB_FILE})
+    # The following is a hack. It takes advantage of the fact that
+    # cmake allows us to define arbitrary linker languages in order
+    # to invoke cargo as our linker command. To do this, we define
+    # a custom language specific to only our target that also takes
+    # in the required environment variables we want to set and the
+    # output file generated by cargo.
+    #
+    # This works by running a cmake script during build-time which
+    # parses the link flags and sends them off to cargo as -Clink-flag=...
+    # For the full details in what's done during build see CargoLink.cmake.
+    #
+    # The upside of this hack is that it allows libraries and binaries
+    # generated by cargo to be used as normal cmake targets. This
+    # means that stuff like target_link_libraries works properly.
+    #
+    # Extra Note: The variables that look like <VAR_NAME> in the string
+    #   below are called expansion variables by the community wiki. They
+    #   don't seem to be documented anywhere in the official docs but
+    #   are hopefully stable.
+    #
+    # Another Note: Since these are required to be global variables we
+    #   push them in the cache as hidden variables.
+    #
+    # Note 3: There is a <FLAGS> expansion rule in the docs which I would
+    #         expect to expand to what was passed in to target_compile_flags.
+    #         Unfortunately, it doesn't, so I've instead just shoved the
+    #         compile flags into linker command template directory.
+    #
+    # The inspiration for this hack came from this SO answer
+    # https://stackoverflow.com/questions/34165365/retrieve-all-link-flags-in-cmake
+    #
+    # "Docs" for the expansion rules can be found here
+    # https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/Build-Rules
+    set(LINK_COMMAND "<CMAKE_COMMAND> -P ${FILE_LIST_DIR}/CargoLink.cmake 'TARGET=<TARGET>' 'LINK_FLAGS=<LINK_FLAGS>' 'LINK_LIBRARIES=<LINK_LIBRARIES>' 'FLAGS=${CRATE_ARGS_STR}' 'OUTPUT=${OUTPUT_FILE}' 'CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}' 'LINK_FLAGS_FILE=${LINK_FLAGS_FILE}' -- ${FORWARDED_VARS}")
+    
+    foreach(VAR ${FORWARDED_VARS})
+        string(APPEND LINK_COMMAND " ${VAR}")
+    endforeach()
+
+    # TODO(sean): disambiguate this based on bin/lib so that multiple targets in
+    #             the same directory don't clash.
+    set(CMAKE_${CARGO_NAME}_LINK_EXECUTABLE ${LINK_COMMAND} CACHE INTERNAL "")
+    set(CMAKE_${CARGO_NAME}_CREATE_STATIC_LIBRARY ${LINK_COMMAND} CACHE INTERNAL "")
+    set(CMAKE_${CARGO_NAME}_CREATE_SHARED_LIBRARY ${LINK_COMMAND} CACHE INTERNAL "")
+    set(CMAKE_${CARGO_NAME}_LINK_FLAGS ${CMAKE_C_LINK_FLAGS} CACHE INTERNAL "")
+    set(CMAKE_${CARGO_NAME}_LINK_DIRECTORIES ${CMAKE_C_LINK_DIRECTORIES} CACHE INTERNAL "")
+
+    # Needed to build when we have test targets
+    set(
+        CMAKE_ECHO_LINK_EXECUTABLE
+        "bash -c \"<CMAKE_COMMAND> -E echo_append <LINK_FLAGS> <LINK_LIBRARIES> > <TARGET>\""
+        CACHE INTERNAL ""
+    )
+    set(CMAKE_ECHO_LINK_FLAGS ${CMAKE_C_LINK_FLAGS} CACHE INTERNAL "")
+    set(CMAKE_ECHO_LINK_DIRECTORIES ${CMAKE_C_LINK_DIRECTORIES} CACHE INTERNAL "")
 
+    set_source_files_properties(
+        ${CRATE_SOURCES}
+        PROPERTY
+        HEADER_FILE_ONLY ON
+    )
+    
+    # CMake doesn't seem to add dependencies on the crate
+    # sources. This means that making changes to a rust
+    # target is rather painful. 
+    # 
+    # We work around this by creating a stamp file that depends
+    # on all the source files in the crate. When a source file
+    # is modified, the stamp file is updated, and this is picked
+    # up since we set the stamp file as a link dependency of
+    # library/binary.
     add_custom_command(
-        OUTPUT ${SHARED_LIB_FILE}
-        COMMAND ${CARGO_ENV_COMMAND} ${CARGO_EXECUTABLE} ARGS ${CARGO_ARGS}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        DEPENDS ${LIB_SOURCES}
-        COMMENT "running cargo")
-    add_custom_target(${CARGO_NAME}_shared_target ALL DEPENDS ${SHARED_LIB_FILE})
-    add_library(${CARGO_NAME}_shared SHARED IMPORTED GLOBAL)
-    add_dependencies(${CARGO_NAME}_shared ${CARGO_NAME}_shared_target)
-    set_target_properties(${CARGO_NAME}_shared PROPERTIES IMPORTED_LOCATION ${SHARED_LIB_FILE})
+        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        DEPENDS ${CRATE_SOURCES}
+        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        COMMENT "checking whether crate sources are up-to-date"
+    )
+
+    # Targets
+    if(CARGO_BIN)
+        # We are building a binary executable
+        add_executable(
+            ${CARGO_NAME}
+            ${CRATE_SOURCES}
+            # Needed so that this file is usable in LINK_DEPENDENCY
+            ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        )
+
+        # Ensure that we use our custom "linker"
+        set_target_properties(
+            ${CARGO_NAME} PROPERTIES
+            LINKER_LANGUAGE ${CARGO_NAME}
+            LINK_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        )
+
+        target_compile_options(${CARGO_NAME} PRIVATE ${CRATE_ARGS})
+    elseif(CARGO_STATIC)
+        # We are building a static library that will be used from C code
+        add_library(
+            ${CARGO_NAME}
+            STATIC
+            ${CRATE_SOURCES}
+            ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        )
+
+        # Ensure that we use our custom "linker"
+        set_target_properties(
+            ${CARGO_NAME} PROPERTIES
+            LINKER_LANGUAGE ${CARGO_NAME}
+            # Needed so that this file is usable in LINK_DEPENDENCY
+            LINK_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/up-to-date.stamp
+        )
+
+        target_compile_options(${CARGO_NAME} PRIVATE ${CRATE_ARGS})
+    else()
+        set(CARGO_ENV_COMMAND ${CMAKE_COMMAND} -E env ${FORWARDED_VARS})
+
+        # We are building a rust-only library. Define it as a interface library
+        add_library(
+            ${CARGO_NAME}
+            INTERFACE
+        )
+
+        if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.13.0")
+            # This is required for dependency detection to work correctly.
+            # However, nothing breaks on a clean build if you don't have it
+            # so we don't make it required.
+            set_target_properties(
+                ${CARGO_NAME} PROPERTIES
+                INTERFACE_LINK_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/build.stamp
+            )
+        endif()
+
+        # However, we still want to build the library, so define a custom command for that
+        add_custom_command(
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/build.stamp
+            COMMAND ${CARGO_ENV_COMMAND} cargo build ${CRATE_ARGS}
+            COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/build.stamp
+            DEPENDS ${CRATE_SOURCES}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            COMMENT "running cargo for target ${CARGO_NAME}"
+        )
+
+        add_custom_target(
+            ${CARGO_NAME}-build
+            ALL DEPENDS
+            ${CMAKE_CURRENT_BINARY_DIR}/build.stamp
+        )
+
+        add_dependencies(${CARGO_NAME} ${CARGO_NAME}-build)
+        add_dependencies(${CARGO_NAME} ${CARGO_NAME}-link-export)
+
+        add_executable(${CARGO_NAME}-link-export Cargo.toml)
+        set_target_properties(
+            ${CARGO_NAME}-link-export PROPERTIES
+            LINKER_LANGUAGE ECHO
+            SUFFIX          ".txt"
+            TARGET_MESSAGES OFF
+        )
+        target_link_libraries(${CARGO_NAME}-link-export $<TARGET_PROPERTY:${CARGO_NAME},INTERFACE_LINK_LIBRARIES>)
+
+        set(LINK_FLAGS_FILE $<TARGET_FILE:${CARGO_NAME}-link-export>)
+    endif()
+
+    if(NOT CARGO_NO_TEST)
+        add_test(
+            NAME test-${CARGO_NAME}
+            COMMAND ${CMAKE_COMMAND} -P "${FILE_LIST_DIR}/CargoTest.cmake" 
+                "LINK_FLAGS_FILE=${LINK_FLAGS_FILE}"
+                "FLAGS=${CRATE_ARGS_STR}"
+                "CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
+                "CMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}"
+                --
+                ${FORWARDED_VARS}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    endif()
 endfunction()
diff --git a/cmake/CMakeDetermineRustCompiler.cmake b/cmake/CMakeDetermineRustCompiler.cmake
deleted file mode 100644
index 33a459c0a..000000000
--- a/cmake/CMakeDetermineRustCompiler.cmake
+++ /dev/null
@@ -1,25 +0,0 @@
-
-if(NOT CMAKE_Rust_COMPILER)
-	find_package(Rust)
-	if(RUST_FOUND)
-		set(CMAKE_Rust_COMPILER "${RUSTC_EXECUTABLE}")
-		set(CMAKE_Rust_COMPILER_ID "Rust")
-		set(CMAKE_Rust_COMPILER_VERSION "${RUST_VERSION}")
-		set(CMAKE_Rust_PLATFORM_ID "Rust")
-	endif()
-endif()
-
-message(STATUS "Cargo Prefix: ${CARGO_PREFIX}")
-message(STATUS "Rust Compiler Version: ${RUSTC_VERSION}")
-
-mark_as_advanced(CMAKE_Rust_COMPILER)
-
-if(CMAKE_Rust_COMPILER)
-	set(CMAKE_Rust_COMPILER_LOADED 1)
-endif(CMAKE_Rust_COMPILER)
-
-configure_file(${CMAKE_SOURCE_DIR}/cmake/CMakeRustCompiler.cmake.in
-	${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${CMAKE_VERSION}/CMakeRustCompiler.cmake IMMEDIATE @ONLY)
-
-set(CMAKE_Rust_COMPILER_ENV_VAR "RUSTC")
-
diff --git a/cmake/CMakeRustCompiler.cmake.in b/cmake/CMakeRustCompiler.cmake.in
deleted file mode 100644
index 5916c1c3d..000000000
--- a/cmake/CMakeRustCompiler.cmake.in
+++ /dev/null
@@ -1,15 +0,0 @@
-
-set(CMAKE_Rust_COMPILER "@CMAKE_Rust_COMPILER@")
-set(CMAKE_Rust_COMPILER_ID "@CMAKE_Rust_COMPILER_ID@")
-set(CMAKE_Rust_COMPILER_VERSION "@CMAKE_Rust_COMPILER_VERSION@")
-set(CMAKE_Rust_COMPILER_LOADED @CMAKE_Rust_COMPILER_LOADED@)
-set(CMAKE_Rust_PLATFORM_ID "@CMAKE_Rust_PLATFORM_ID@")
-
-SET(CMAKE_Rust_SOURCE_FILE_EXTENSIONS rs)
-SET(CMAKE_Rust_LINKER_PREFERENCE 40)
-#SET(CMAKE_Rust_OUTPUT_EXTENSION_REPLACE 1)
-SET(CMAKE_STATIC_LIBRARY_PREFIX_Rust "")
-SET(CMAKE_STATIC_LIBRARY_SUFFIX_Rust .a)
-
-set(CMAKE_Rust_COMPILER_ENV_VAR "RUSTC")
-
diff --git a/cmake/CMakeRustInformation.cmake b/cmake/CMakeRustInformation.cmake
deleted file mode 100644
index 05d96c94b..000000000
--- a/cmake/CMakeRustInformation.cmake
+++ /dev/null
@@ -1,106 +0,0 @@
-
-# 
-# Usage: rustc [OPTIONS] INPUT
-# 
-# Options:
-#     -h --help           Display this message
-#     --cfg SPEC          Configure the compilation environment
-#     -L [KIND=]PATH      Add a directory to the library search path. The
-#                         optional KIND can be one of dependency, crate, native,
-#                         framework or all (the default).
-#     -l [KIND=]NAME      Link the generated crate(s) to the specified native
-#                         library NAME. The optional KIND can be one of static,
-#                         dylib, or framework. If omitted, dylib is assumed.
-#     --crate-type [bin|lib|rlib|dylib|cdylib|staticlib|metadata]
-#                         Comma separated list of types of crates for the
-#                         compiler to emit
-#     --crate-name NAME   Specify the name of the crate being built
-#     --emit [asm|llvm-bc|llvm-ir|obj|link|dep-info]
-#                         Comma separated list of types of output for the
-#                         compiler to emit
-#     --print [crate-name|file-names|sysroot|cfg|target-list|target-cpus|target-features|relocation-models|code-models]
-#                         Comma separated list of compiler information to print
-#                         on stdout
-#     -g                  Equivalent to -C debuginfo=2
-#     -O                  Equivalent to -C opt-level=2
-#     -o FILENAME         Write output to <filename>
-#     --out-dir DIR       Write output to compiler-chosen filename in <dir>
-#     --explain OPT       Provide a detailed explanation of an error message
-#     --test              Build a test harness
-#     --target TARGET     Target triple for which the code is compiled
-#     -W --warn OPT       Set lint warnings
-#     -A --allow OPT      Set lint allowed
-#     -D --deny OPT       Set lint denied
-#     -F --forbid OPT     Set lint forbidden
-#     --cap-lints LEVEL   Set the most restrictive lint level. More restrictive
-#                         lints are capped at this level
-#     -C --codegen OPT[=VALUE]
-#                         Set a codegen option
-#     -V --version        Print version info and exit
-#     -v --verbose        Use verbose output
-# 
-# Additional help:
-#     -C help             Print codegen options
-#     -W help             Print 'lint' options and default settings
-#     -Z help             Print internal options for debugging rustc
-#     --help -v           Print the full set of options rustc accepts
-# 
-
-# <TARGET> <TARGET_BASE> <OBJECT> <OBJECTS> <LINK_LIBRARIES> <FLAGS> <LINK_FLAGS> <SOURCE> <SOURCES>
-
-include(CMakeLanguageInformation)
-
-if(UNIX)
-	set(CMAKE_Rust_OUTPUT_EXTENSION .o)
-else()
-	set(CMAKE_Rust_OUTPUT_EXTENSION .obj)
-endif()
-
-set(CMAKE_Rust_ECHO_ALL "echo \"TARGET: <TARGET> TARGET_BASE: <TARGET_BASE> ")
-set(CMAKE_Rust_ECHO_ALL "${CMAKE_Rust_ECHO_ALL} OBJECT: <OBJECT> OBJECTS: <OBJECTS> OBJECT_DIR: <OBJECT_DIR> SOURCE: <SOURCE> SOURCES: <SOURCES> ")
-set(CMAKE_Rust_ECHO_ALL "${CMAKE_Rust_ECHO_ALL} LINK_LIBRARIES: <LINK_LIBRARIES> FLAGS: <FLAGS> LINK_FLAGS: <LINK_FLAGS> \"")
-
-if(NOT CMAKE_Rust_CREATE_SHARED_LIBRARY)
-	set(CMAKE_Rust_CREATE_SHARED_LIBRARY
-		"echo \"CMAKE_Rust_CREATE_SHARED_LIBRARY\""
-		"${CMAKE_Rust_ECHO_ALL}"
-		)
-endif()
-
-if(NOT CMAKE_Rust_CREATE_SHARED_MODULE)
-	set(CMAKE_Rust_CREATE_SHARED_MODULE
-		"echo \"CMAKE_Rust_CREATE_SHARED_MODULE\""
-		"${CMAKE_Rust_ECHO_ALL}"
-		)
-endif()
-
-if(NOT CMAKE_Rust_CREATE_STATIC_LIBRARY)
-	set(CMAKE_Rust_CREATE_STATIC_LIBRARY
-		"echo \"CMAKE_Rust_CREATE_STATIC_LIBRARY\""
-		"${CMAKE_Rust_ECHO_ALL}"
-		)
-endif()
-
-if(NOT CMAKE_Rust_COMPILE_OBJECT)
-	set(CMAKE_Rust_COMPILE_OBJECT
-		"echo \"CMAKE_Rust_COMPILE_OBJECT\""
-		"${CMAKE_Rust_ECHO_ALL}"
-		"${CMAKE_Rust_COMPILER} --emit obj <SOURCE> -o <OBJECT>")
-endif()
-
-if(NOT CMAKE_Rust_LINK_EXECUTABLE)
-	set(CMAKE_Rust_LINK_EXECUTABLE
-		"echo \"CMAKE_Rust_LINK_EXECUTABLE\""
-		"${CMAKE_Rust_ECHO_ALL}"
-		)
-endif()
-
-mark_as_advanced(
-	CMAKE_Rust_FLAGS
-	CMAKE_Rust_FLAGS_DEBUG
-	CMAKE_Rust_FLAGS_MINSIZEREL
-	CMAKE_Rust_FLAGS_RELEASE
-	CMAKE_Rust_FLAGS_RELWITHDEBINFO)
-
-set(CMAKE_Rust_INFORMATION_LOADED 1)
-
diff --git a/cmake/CMakeTestRustCompiler.cmake b/cmake/CMakeTestRustCompiler.cmake
deleted file mode 100644
index ff75bb3e0..000000000
--- a/cmake/CMakeTestRustCompiler.cmake
+++ /dev/null
@@ -1,3 +0,0 @@
-
-set(CMAKE_Rust_COMPILER_WORKS 1 CACHE INTERNAL "")
-
diff --git a/cmake/CargoLink.cmake b/cmake/CargoLink.cmake
new file mode 100644
index 000000000..940eb907f
--- /dev/null
+++ b/cmake/CargoLink.cmake
@@ -0,0 +1,105 @@
+# ccommon - a cache common library.
+# Copyright (C) 2019 Twitter, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Ensure that empty elements in lists aren't deleted
+cmake_policy(SET CMP0007 NEW)
+
+# Ignore the first 3 arguments since they will always be cmake -P <some path>/LinkRust.cmake
+set(ARGI 3)
+# This flips once we see -- in the arguments
+set(PARSING_ENV_VARS OFF)
+# Arguments to be passed directly to the build command
+set(PASSTHROUGH_VARS )
+
+# Split up the command-line arguments to this script
+# into two groups
+#
+# Arguments before '--' are cmake variables that we set
+# in this script. These are parameters which control the
+# behaviour here.
+#
+# Arguments after '--' are environment variables to pass
+# through to the cargo invocation, they are used by build
+# scripts and to control cargo behaviour.
+while(ARGI LESS ${CMAKE_ARGC})
+    set(CURRENT_ARG ${CMAKE_ARGV${ARGI}})
+
+    if(NOT PARSING_ENV_VARS)
+        if(CURRENT_ARG STREQUAL "--")
+            set(PARSING_ENV_VARS ON)
+        else()
+            string(REPLACE "=" ";" ARGLIST "${CURRENT_ARG}")
+
+            list(GET ARGLIST 0 VAR)
+            list(REMOVE_AT ARGLIST 0)
+            string(REPLACE ";" "=" VALUE "${ARGLIST}")
+
+            set(${VAR} "${VALUE}")
+        endif()
+    else()
+        list(APPEND PASSTHROUGH_VARS "${CURRENT_ARG}")
+    endif()
+
+    math(EXPR ARGI "${ARGI} + 1")
+endwhile()
+
+file(
+    WRITE
+    "${LINK_FLAGS_FILE}"
+    ${LINK_FLAGS} ${LINK_LIBRARIES}
+)
+
+# This converts a space-delimited string to a cmake list
+string(REPLACE " " ";" LINK_FLAGS_LIST "${LINK_LIBRARIES}" "${LINK_FLAGS}")
+set(LINK_FLAGS )
+
+# To pass linker args through cargo we need to use
+# the -Clink-arg=<flag> syntax.
+foreach(FLAG ${LINK_FLAGS_LIST})
+    if(EXISTS "${FLAG}")
+        get_filename_component(FLAG "${FLAG}" ABSOLUTE)
+    endif()
+
+    list(APPEND LINK_FLAGS "-Clink-arg=${FLAG}")
+endforeach()
+
+string(REPLACE ";" " " LINK_FLAGS "${LINK_FLAGS}")
+string(REPLACE " " ";" FLAGS "${FLAGS}")
+
+# TODO(sean): We don't always want to colour the output. Is
+#             there a way to autodetect this properly?
+set(CARGO_COMMAND cargo build --color always ${FLAGS})
+
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -E env ${PASSTHROUGH_VARS} "RUSTFLAGS=${LINK_FLAGS}" ${CARGO_COMMAND}
+    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+    RESULT_VARIABLE STATUS
+)
+
+# Ensure that our script exits with the correct error code.
+# The only way to get a cmake script to exit with an error
+# code is to print a message so that's what we do here.
+if(NOT STATUS EQUAL 0)
+    message(FATAL_ERROR "Cargo build failed")
+endif()
+
+# Get the directory above TARGET since file(COPY ...)
+# uses a directory as the destination
+get_filename_component(
+    TARGET "${TARGET}/.."
+    ABSOLUTE
+)
+
+file(COPY "${OUTPUT}" DESTINATION "${TARGET}")
diff --git a/cmake/CargoTest.cmake b/cmake/CargoTest.cmake
new file mode 100644
index 000000000..88bfeebb6
--- /dev/null
+++ b/cmake/CargoTest.cmake
@@ -0,0 +1,99 @@
+# ccommon - a cache common library.
+# Copyright (C) 2019 Twitter, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Ensure that empty elements in lists aren't deleted
+cmake_policy(SET CMP0007 NEW)
+
+# Ignore the first 3 arguments since they will always be cmake -P <some path>/LinkRust.cmake
+set(ARGI 3)
+# This flips once we see -- in the arguments
+set(PARSING_ENV_VARS OFF)
+# Arguments to be passed directly to the build command
+set(PASSTHROUGH_VARS )
+
+# Split up the command-line arguments to this script
+# into two groups
+#
+# Arguments before '--' are cmake variables that we set
+# in this script. These are parameters which control the
+# behaviour here.
+#
+# Arguments after '--' are environment variables to pass
+# through to the cargo invocation, they are used by build
+# scripts and to control cargo behaviour.
+while(ARGI LESS ${CMAKE_ARGC})
+    set(CURRENT_ARG ${CMAKE_ARGV${ARGI}})
+
+    if(NOT PARSING_ENV_VARS)
+        if(CURRENT_ARG STREQUAL "--")
+            set(PARSING_ENV_VARS ON)
+        else()
+            string(REPLACE "=" ";" ARGLIST "${CURRENT_ARG}")
+
+            list(GET ARGLIST 0 VAR)
+            list(REMOVE_AT ARGLIST 0)
+            string(REPLACE ";" "=" VALUE "${ARGLIST}")
+
+            set(${VAR} "${VALUE}")
+        endif()
+    else()
+        list(APPEND PASSTHROUGH_VARS "${CURRENT_ARG}")
+    endif()
+
+    math(EXPR ARGI "${ARGI} + 1")
+endwhile()
+
+file(
+    READ
+    "${LINK_FLAGS_FILE}"
+    LINK_FLAGS
+)
+
+# This converts a space-delimited string to a cmake list
+string(REPLACE " " ";" LINK_FLAGS_LIST "${LINK_FLAGS}")
+set(LINK_FLAGS )
+
+# To pass linker args through cargo we need to use
+# the -Clink-arg=<flag> syntax.
+foreach(FLAG ${LINK_FLAGS_LIST})
+    if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${FLAG}")
+        get_filename_component(FLAG "${CMAKE_CURRENT_BINARY_DIR}/${FLAG}" ABSOLUTE)
+    endif()
+
+    list(APPEND LINK_FLAGS "-Clink-arg=${FLAG}")
+endforeach()
+
+string(REPLACE ";" " " LINK_FLAGS "${LINK_FLAGS}")
+string(REPLACE " " ";" FLAGS "${FLAGS}")
+
+# TODO(sean): We don't always want to colour the output. Is
+#             there a way to autodetect this properly?
+set(CARGO_COMMAND cargo test --color always ${FLAGS})
+
+execute_process(
+    COMMAND ${CMAKE_COMMAND} -E env ${PASSTHROUGH_VARS} "RUSTFLAGS=${LINK_FLAGS}" ${CARGO_COMMAND}
+    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+    RESULT_VARIABLE STATUS
+)
+
+# Ensure that our script exits with the correct error code.
+# The only way to get a cmake script to exit with an error
+# code is to print a message so that's what we do here.
+if(NOT STATUS EQUAL 0)
+    # Dump some script state to help with debugging
+    message(STATUS "PASSTHROUGH_VARS=${PASSTHROUGH_VARS}")
+
+    message(FATAL_ERROR "cargo test failed")
+endif()
diff --git a/cmake/FindCheck.cmake b/cmake/FindCHECK.cmake
similarity index 100%
rename from cmake/FindCheck.cmake
rename to cmake/FindCHECK.cmake
diff --git a/cmake/FindITTNOTIFY.cmake b/cmake/FindITTNOTIFY.cmake
new file mode 100644
index 000000000..0c1ae6bc5
--- /dev/null
+++ b/cmake/FindITTNOTIFY.cmake
@@ -0,0 +1,65 @@
+# ITTNOTIFY is the instrumentation and tracing technology (ITT) APIs provided by
+# the Intel® VTune™Amplifier enable your application to generate and control
+# the collection of trace data during its execution.
+#
+# The following variables are set when ITTNOTIFY is found:
+#  ITTNOTIFY_FOUND          = Set to true, if all components of ITTNOTIFY have been found.
+#  ITTNOTIFY_INCLUDE_DIRS   = Include path for the header files of ITTNOTIFY.
+#  ITTNOTIFY_LIBRARY_DIRS   = Library search path for the ITTNOTIFY libraries.
+#  ITTNOTIFY_LIBRARIES      = Link these to use ITTNOTIFY.
+#  ITTNOTIFY_LFLAGS         = Linker flags (optional).
+
+if (NOT ITTNOTIFY_FOUND)
+
+  find_program(VTUNE_EXECUTABLE amplxe-cl)
+
+  if(NOT VTUNE_EXECUTABLE)
+    set(ITTNOTIFY_FOUND false)
+      return()
+  endif()
+
+  get_filename_component(VTUNE_DIR ${VTUNE_EXECUTABLE} PATH)
+  set(ITTNOTIFY_ROOT_DIR "${VTUNE_DIR}/..")
+
+  ##_____________________________________________________________________________
+  ## Check for the header files
+
+  find_path (ITTNOTIFY_INCLUDE_DIRS
+    NAMES ittnotify.h
+    HINTS ${ITTNOTIFY_ROOT_DIR}
+    PATHS /usr /usr/local
+    PATH_SUFFIXES include
+    )
+
+  ##_____________________________________________________________________________
+  ## Check for the library
+
+  find_library (ITTNOTIFY_LIBRARIES ittnotify
+    HINTS ${ITTNOTIFY_ROOT_DIR}
+    PATHS /usr /usr/local /opt/local
+    PATH_SUFFIXES lib64 lib
+    )
+
+  ##_____________________________________________________________________________
+  ## Actions taken when all components have been found
+
+  find_package_handle_standard_args (ITTNOTIFY DEFAULT_MSG ITTNOTIFY_LIBRARIES ITTNOTIFY_INCLUDE_DIRS)
+
+  if (ITTNOTIFY_FOUND)
+    if (NOT ITTNOTIFY_FIND_QUIETLY)
+      message (STATUS "Found components for ITTNOTIFY")
+      message (STATUS "ITTNOTIFY_ROOT_DIR  = ${ITTNOTIFY_ROOT_DIR}")
+      message (STATUS "ITTNOTIFY_INCLUDE_DIRS  = ${ITTNOTIFY_INCLUDE_DIRS}")
+      message (STATUS "ITTNOTIFY_LIBRARIES = ${ITTNOTIFY_LIBRARIES}")
+    endif (NOT ITTNOTIFY_FIND_QUIETLY)
+  else (ITTNOTIFY_FOUND)
+    if (ITTNOTIFY_FIND_REQUIRED)
+      message (FATAL_ERROR "Could not find ITTNOTIFY!")
+    endif (ITTNOTIFY_FIND_REQUIRED)
+  endif (ITTNOTIFY_FOUND)
+
+  if(UNIX)
+    list(APPEND ITTNOTIFY_LIBRARIES dl)
+  endif()
+
+endif (NOT ITTNOTIFY_FOUND)
diff --git a/cmake/FindRust.cmake b/cmake/FindRust.cmake
index 2dbf14ddf..53127a103 100644
--- a/cmake/FindRust.cmake
+++ b/cmake/FindRust.cmake
@@ -4,55 +4,53 @@ set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH)
 set(_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ${CMAKE_FIND_ROOT_PATH_MODE_INCLUDE})
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH)
 
-if(WIN32)
+if(CMAKE_HOST_WIN32)
 	set(USER_HOME "$ENV{USERPROFILE}")
 else()
 	set(USER_HOME "$ENV{HOME}")
 endif()
 
-# Find cargo prefix
-find_path(CARGO_PREFIX ".cargo"
-	PATHS "${USER_HOME}")
-
-if(CARGO_PREFIX MATCHES "NOTFOUND")
-	message(FATAL_ERROR "Could not find Rust!")
-else()
-	set(CARGO_PREFIX "${CARGO_PREFIX}/.cargo")
+if(NOT DEFINED CARGO_HOME)
+	if("$ENV{CARGO_HOME}" STREQUAL "")
+		set(CARGO_HOME "${USER_HOME}/.cargo")
+	else()
+		set(CARGO_HOME "$ENV{CARGO_HOME}")
+	endif()
 endif()
 
 # Find cargo executable
 find_program(CARGO_EXECUTABLE cargo
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(CARGO_EXECUTABLE)
 
 # Find rustc executable
 find_program(RUSTC_EXECUTABLE rustc
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(RUSTC_EXECUTABLE)
 
 # Find rustdoc executable
 find_program(RUSTDOC_EXECUTABLE rustdoc
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(RUSTDOC_EXECUTABLE)
 
 # Find rust-gdb executable
 find_program(RUST_GDB_EXECUTABLE rust-gdb
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(RUST_GDB_EXECUTABLE)
 
 # Find rust-lldb executable
 find_program(RUST_LLDB_EXECUTABLE rust-lldb
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(RUST_LLDB_EXECUTABLE)
 
 # Find rustup executable
 find_program(RUSTUP_EXECUTABLE rustup
-	HINTS "${CARGO_PREFIX}"
+	HINTS "${CARGO_HOME}"
 	PATH_SUFFIXES "bin")
 mark_as_advanced(RUSTUP_EXECUTABLE)
 
@@ -61,7 +59,7 @@ set(RUST_FOUND FALSE CACHE INTERNAL "")
 if(CARGO_EXECUTABLE AND RUSTC_EXECUTABLE AND RUSTDOC_EXECUTABLE)
 	set(RUST_FOUND TRUE CACHE INTERNAL "")
 
-	set(CARGO_PREFIX "${CARGO_PREFIX}" CACHE PATH "Rust Cargo prefix")
+	set(CARGO_HOME "${CARGO_HOME}" CACHE PATH "Rust Cargo Home")
 
 	execute_process(COMMAND ${RUSTC_EXECUTABLE} --version OUTPUT_VARIABLE RUSTC_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
 	string(REGEX REPLACE "rustc ([^ ]+) .*" "\\1" RUSTC_VERSION "${RUSTC_VERSION}")
diff --git a/config.h.in b/config.h.in
index f1dc18bd9..f2fe91ba5 100644
--- a/config.h.in
+++ b/config.h.in
@@ -12,10 +12,12 @@
 
 #cmakedefine HAVE_BACKTRACE
 
-#cmakedefine HAVE_BIG_ENDIAN
+#cmakedefine HAVE_ACCEPT4
 
 #cmakedefine HAVE_LOGGING
 
 #cmakedefine HAVE_STATS
 
 #cmakedefine HAVE_DEBUG_MM
+
+#cmakedefine HAVE_ITT_INSTRUMENTATION
diff --git a/docs/c-styleguide.txt b/docs/c-styleguide.txt
deleted file mode 100644
index 69661c0d8..000000000
--- a/docs/c-styleguide.txt
+++ /dev/null
@@ -1,427 +0,0 @@
-- No literal tabs. Expand tabs to 4 spaces.
-- Indentation is 4 spaces.
-- No more than 3 levels of indentation, otherwise you should think about
-  refactoring your code.
-- Use one statement per line.
-- Make sure that your editor does not leave space at the end of the line.
-- snake_case for variable, function and file names.
-- Use your own judgment when naming variables and functions. Be as Spartan
-  as possible. Eg: Using name like this_variable_is_a_temporary_counter
-  will usually be frowned upon.
-- Don’t use local variables or parameters that shadow global identifiers.
-  GCC’s ‘-Wshadow’ option can help you to detect this problem.
-
-- Avoid using int, char, short, long. Instead use int8_t uint8_t, int16_t,
-  uint16_t, int32_t, uint32_t, int64_t, uint64_t, which are available in
-  <stdint.h>. However, when interfacing with system calls and libraries
-  you cannot get away from using int and char.
-- Use bool for boolean variables. You have to include <stdbool.h>
-- If memory usage or alignment is a concern, avoid using a bool as type for
-  struct member names. Instead use unsigned 1-bit bit field. e.g.
-  struct foo {
-      unsigned is_bar:1;
-  };
-  However, if neither memory usage or alignment will be significantly impacted
-  by the struct, opt for using bool for the sake of readability.
-- Always use size_t type when dealing with sizes of objects or memory ranges.
-- Your code should be 64-bit and 32-bit friendly. Bear in mind problems
-  of printing, comparisons, and structure alignment. You have to include
-  <intyptes.h> to get generic format specifier macros for printing.
-
-- 80 column line limit.
-- If you have to wrap a long statement (> 80 column), put the operator at the
-  end of the line and indent the next line at the same column as the arguments
-  in the previous column. Eg:
-    while (cnt < 20 && this_variable_name_is_too_long &&
-           ep != NULL) {
-        z = a + really + long + statement + that + needs + three + lines +
-            gets + indented + on + the + same + column + as + the +
-            previous + column
-    }
-
-    and:
-
-    int a = function(param_a, param_b, param_c, param_d, param_e, param_f,
-                     param_g, param_h, param_i, param_j, param_k, param_l);
-
-- Always use braces for all conditional blocks (if, switch, for, while, do).
-  This holds good even for single statement conditional blocks. Eg:
-    if (cond) {
-        stmt;
-    }
-- Placement of braces for non-function statement blocks - put opening brace
-  last on the line and closing brace first. Eg:
-    if (x is true) {
-        we do y
-    }
-- Placement of brace for functions - put the opening brace at the beginning
-  of the next line and closing brace first. This is useful because several
-  tools look for opening brace in column one to find beginning of C
-  functions. Eg:
-int
-function(int x)
-{
-    body of the function
-}
-
-- Closing brace is empty on a line of its own, except in cases where it is
-  followed by a continuation of the same statement, i.e. a "while" in a
-  do-statement or an "else" in an if-statement, like this:
-    do {
-        body of do-loop
-    } while (condition);
-
-    and,
-
-    if (x == y) {
-        ..
-    } else if (x > y) {
-        ...
-    } else {
-        ....
-    }
-
-- Column align switch keyword and the corresponding case/default keyword. Eg:
-    switch (alphabet) {
-    case 'a':
-    case 'b':
-        printf("I am a or b\n");
-        break;
-
-    default:
-        break;
-    }
-
-- Forever loops are done with for, and not while. Eg:
-    for (;;) {
-        stmt;
-    }
-
-- Don't use a space after a function name.
-- Do not needlessly surround the return expression with parentheses.
-- Use space after keywords. Exceptions are sizeof, typeof, alignof and
-  __attribute__, which look like functions.
-- Do not add spaces around (inside) parenthesized expressions.
-    s = sizeof( sizeof(*p)) ); /* bad example */
-    s = sizeof(sizeof(*p));    /* good example */
-- Casts should not be followed by space. Eg:
-  int q = *(int *)&p
-- There is no need to type cast when assigning a void pointer to a non-void
-  pointer, or vice versa.
-- Avoid using goto statements. However there are some exceptions to this rule
-  when a single goto label within a function and one or more goto statements
-  come in handy when a function exits from multiple locations and some common
-  work such as cleanup has to be done. Eg:
-int
-fun(void)
-{
-    int result = 0;
-    char *buffer;
-
-    buffer = malloc(1024);
-    if (buffer == NULL) {
-        return -1;
-    }
-
-    if (condition1) {
-        while (loop1) {
-            ...
-        }
-        result = 1;
-        goto out;
-    }
-
-    ...
-out:
-    free(buffer);
-    return result;
-}
-- When declaring pointer data, use '*' adjacent to the data name and not
-  adjacent to the type name. Eg:
-    int
-    function(int *p)
-    {
-        char *p;
-        <body of the function>
-    }
-- Use one space around (on each side of) most binary and ternary operators,
-  such as any of these:
-    =  +  -  <  >  *  /  %  |  &  ^  <=  >=  ==  !=  ?  :
-  but no space after unary operators:
-    &  *  +  -  ~  !  sizeof typeof alignof  __attribute__  defined
-  no space before the postfix increment & decrement unary operators:
-    ++  --
-  and no space around the '.' and "->" structure member operators.
-
-- 0 and NULL; use 0 for integers, 0.0 for doubles, NULL for pointers, and
-  '\0' for chars.
-- Test pointers against NULL. E.g, use:
-    if (p == NULL)
-
-    not:
-
-    !(p)
-
-- Do not use ! for tests unless it is a boolean. E.g. use:
-    if (*p == '\0')
-
-    not:
-
-    if (!*p)
-
-- Don't use assignments inside if or while-conditions. E.g, use:
-
-    struct foo *foo;
-    foo = malloc(sizeof(*foo));
-    if (foo == NULL) {
-        return -1
-    }
-
-    not:
-
-    struct foo *foo;
-    if ((foo = malloc(sizeof(*foo))) == NULL) {
-        return -1;
-    }
-
-- Don't ever use typedef for structure types. Typedefs are problematic
-  because they do not properly hide their underlying type; for example you
-  need to know if the typedef is the structure itself or a pointer to the
-  structure. In addition they must be declared exactly once, whereas an
-  incomplete structure type can be mentioned as many times as necessary.
-  Typedefs are difficult to use in stand-alone header files: the header
-  that defines the typedef must be included before the header that uses it,
-  or by the header that uses it (which causes namespace pollution), or
-  there must be a back-door mechanism for obtaining the typedef.
-- The only exception for using a typedef is when you are defining a type
-  for a function pointer or a type for an enum. Eg:
-
-  typedef void (*foo_handler_t)(int, void *);
-
-  or:
-
-  typedef enum types {
-      TYPE_1,
-      TYPE_2
-  } types_t;
-
-- Use just one variable declaration per line when variables are part of a
-  struct. This leaves you room for a small comment on each item, explaining
-  its use. Declarations should also be aligned. Eg, use:
-
-  struct foo {
-    int      *foo_a;   /* comment for foo_a */
-    int      foo_b;    /* comment for foo_b */
-    unsigned foo_c:1;  /* comment for foo_c */
-  };
-
-  and not:
-
-  struct foo {
-    int *foo_a, foo_b;
-    unsigned foo_c:1;
-  };
-
-- For variable declaration outside a struct, either collect all the
-  declarations of the same type on a single line, or use one variable
-  per line if the variables purpose needs to be commented. Eg:
-  char *a, *b, c;
-
-  or:
-
-  char *a, *b;
-  char c;       /* comments for c */
-
-- Avoid magic numbers because no-one has a clue (including the author) of
-  what it means after a month.
-
-- Function definitions should start the name of the function in column
-  one. This is useful because it makes searching for function definitions
-  fairly trivial. Eg:
-static char *
-concat(char *s1, char *s2)
-{
-  body of the function
-}
-
-- Function and variables local to a file should be static.
-- Separate two successive functions with one blank line.
-- Include parameter names with their datypes in function declaration. Eg:
-void function(int param);
-
-- Functions should be short and sweet, and do just one thing. They should
-  fit on one or two screenfuls of text (80 x 24 screen size), and do one
-  thing and do that well.
-  The maximum length of a function is inversely proportional to the
-  complexity and indentation level of that function. So, if you have a
-  conceptually simple function that is just one long (but simple)
-  case-statement, where you have to do lots of small things for a lot of
-  different cases, it's OK to have a longer function.
-  Another measure of the function is the number of local variables. They
-  shouldn't exceed 5-10, or you're doing something wrong. Re-think the
-  function, and split it into smaller pieces. A human brain can
-  generally easily keep track of about 7 different things, anything more
-  and it gets confused. You know you're brilliant, but maybe you'd like
-  to understand what you did 2 weeks from now.
-- Use const for function parameters passed by reference, if the passed
-  pointer has no side effect.
-
-- C style comments only. Don't use // for single line comments. Instead
-  use /* ... */ style.
-- For multi-line comments use the following style
-    /*
-     * This is the preferred style for multi-line
-     * comments in the Linux kernel source code.
-     * Please use it consistently.
-     *
-     * Description:  A column of asterisks on the left side,
-     * with beginning and ending almost-blank lines.
-     */
-
-- To comment out block of code spanning several lines use preprocessor
-  directive "#ifdef 0 ... #endif"
-
-- Please write a brief comment at the start of each source file, with the
-  file name and a line or two about the overall purpose of the file.
-
-- All major functions should have comments describing what they do at the
-  head of the function. Avoid putting comments in the function body unless
-  absolutely needed. If possible, add a comment on what sorts of arguments
-  the function gets, and what the possible values of arguments mean and
-  what they are used for and the significance of return value if there is
-  one. It is not necessary to duplicate in words the meaning of the C
-  argument declarations, if a C type is being used in its customary fashion.
-  If there is anything nonstandard about its use (such as an argument of
-  type char * which is really the address of the second character of a
-  string, not the first), or any possible values that would not work the
-  way one would expect (such as, that strings containing newlines are not
-  guaranteed to work), be sure to say so. Eg:
-
-/*
- * Try to acquire a physical address lock while a pmap is locked. If we
- * fail to trylock we unlock and lock the pmap directly and cache the
- * locked pa in *locked. The caller should then restart their loop in case
- * the virtual to physical mapping has changed.
- *
- * Returns 0 on success and -1 on failure.
- */
-int
-vm_page_pa_tryrelock(pmap_t pmap, vm_paddr_t pa, vm_paddr_t *locked)
-{
-    ...
-
-- The comment on a function is much clearer if you use the argument names
-  to speak about the argument values. The variable name itself should be
-  lower case, but write it in upper case when you are speaking about the
-  value rather than the variable itself. Thus, “the inode number NODE_NUM”
-  rather than “an inode”.
-
-- Every struct definition should have an accompanying comment that
-  describes what it is for and how it should be used.
-
-- Finally, while comments are absolutely important to keep the code readable,
-  remember that the best code is self-documenting. Giving sensible names to
-  types and variables is much better than using obscure names that you must
-  then explain through comments.
-
-- Recommend using UPPERCASE for macro names. However, sometimes using
-  lowercase for macro names makes sense when macros masquerade as well-known
-  function calls. Eg, it makes sense to write the wrapper for the
-  standard free() function in lowercase to keep the readability
-  consistent:
-
-#define my_free(_p) do {    \
-    free(_p);               \
-    (_p) = NULL;            \
-} while (0)
-
-- Use enums when defining more than one related constants. All enumeration
-  values are in UPPERCASE.
-- Avoid macros as much as possible and use inline functions, enums and const
-  variables wherever you can.
-- For macros encapsulating compound statements, right justify the backslashes
-  and enclose it in do { ... } while (0)
-- For parameterized macros, all the parameters used in the macro body must
-  be surrounded by parentheses. Eg:
-  #define ADD_1(_x) ((_x) + 1)
-
-- Use sizeof(varname) instead of sizeof(type) whenever possible. Eg:
-  char *p;
-  p = malloc(sizeof(*p));   /* good example */
-  p = malloc(sizeof(char)); /* bad example */
-
-- All variables should be declared at the beginning of a scope block {..}.
-  It is even preferred to declare all variables at the beginning of the
-  function so that all the local variable declarations is in one place and
-  we can see the comprehensive list in one glance.
-- Global structs should be declared at the top of the file in which they
-  are used, or in separate header files if they are used in multiple
-  source files.
-- Declarations of external functions and functions to appear later in the
-  source file should all go in one place near the beginning of the file,
-  somewhere before the first function definition in the file or else
-  should go in a header file.
-- Use of extern should be considered as evil, if it is used in header files
-  to reference global variables.
-- Don’t put extern declarations inside functions.
-
-- Usually every *.c file should have an associated *.h file. There are some
-  exceptions to this rule, such as unit tests and small *.c files containing
-  just the main() function.
-- Every header file in the source code must have preprocessor conditional
-  to prevent the header file from being scanned multiple times and avoiding
-  mutual dependency cycles. Alternatively you can use #pragma once directive,
-  as it avoids name clashes and increases the compile speed. Eg, for a
-  header file named foo.h, the entire contents of the header file must be
-  between the guard macros as follows:
-
-#ifndef _FOO_H_
-#define _FOO_H_
-...
-#endif /* _FOO_H_ */
-
-Or,
-
-#pragma once
-#ifndef _FOO_H_
-#define _FOO_H_
-...
-#endif /* _FOO_H_ */
-
-- Don't use #include when a forward declaration would suffice.
-- Functions defined in header files should be static inline.
-
-- Don’t make the program ugly just to placate GCC when extra warnings options
-  such as ‘-Wconversion’ or ‘-Wundef’ are used. These options can help in
-  finding bugs, but they can also generate so many false alarms that that
-  it hurts readability to silence them with unnecessary casts, wrappers, and
-  other complications.
-
-- Conditional compilation: when supporting configuration options already
-  known when building your program we prefer using if (... ) over conditional
-  compilation, as in the former case the compiler is able to perform more
-  extensive checking of all possible code paths. Eg, use:
-
-  if (HAS_FOO)
-    ...
-  else
-    ...
-
-instead of:
-
-  #ifdef HAS_FOO
-    ...
-  #else
-    ...
-  #endif
-
-  A modern compiler such as GCC will generate exactly the same code in both
-  cases and of course, the former method assumes that HAS_FOO is defined as
-  either 0 or 1.
-
-- Finally, rules are rules. Sometimes they are sensible and sometimes not
-  and regardless of your preference, we would like you to follow them.
-  A project is easier to follow if all project contributors follow the style
-  rules so that they can all read and understand everyone's code easily. But
-  remember, like all good rules, they are exceptions where it makes sense not
-  to be too rigid on the grounds of common sense and consistency!
diff --git a/docs/coding_style.rst b/docs/coding_style.rst
new file mode 100644
index 000000000..0a6a7bdfe
--- /dev/null
+++ b/docs/coding_style.rst
@@ -0,0 +1,583 @@
+Introduction
+============
+
+The C Style Guide is a set of guidelines and conventions that encourage
+good code. While some suggestions are more strict than others, you should
+always practice good judgement.
+
+If following the guide causes unnecessary hoop-jumping or otherwise
+less-readable code, *readability trumps the guide*. However, if the more
+readable variant comes with perils or pitfalls, readability may be
+sacrificed.
+
+Consistency is crucial. Without consistent application, there simply is no style
+to speak of [#fn1]_. Stay in sync with the rest of the codebase; when you want
+to change a rule or style, change it everywhere.
+
+Contents
+--------
+
+.. toctree::
+   :maxdepth: 1
+
+   coding_style
+
+
+C Standard
+==========
+
+- Use ``-std=c11`` when compiling
+- Avoid ``_Atomic``, ``_Generic`` and ``_Thread_local``, for now. We will
+  embrace ``C11`` fully when Twitter's official ``GCC`` is bumped to 4.9.
+
+Indentation
+===========
+
+- Do not use literal tabs. Expand tabs to **four** spaces instead.
+- Use **four** spaces for every indentation level.
+- Do not use more than **four** levels of indentation unless there's a good
+  reason.
+- Make sure that your editor does not leave space at the end of each line.
+- When a block of code resembles a table, such as in a macro-block or struct
+  definition, start each field on a ``4k+1`` column, so all fields are **four**
+  space aligned.
+
+  .. code-block:: c
+
+        /*          name            type            description        */
+        #define FOO_METRIC(ACTION)                                      \
+            ACTION( foo_free,       METRIC_GAUGE,   "# free foo"       )\
+            ACTION( foo_borrow,     METRIC_COUNTER, "# foos borrowed"  )\
+            ACTION( foo_return,     METRIC_COUNTER, "# foos returned"  )\
+        /* name starts on column 13
+         * type starts on column 29
+         * description on column 45
+         */
+
+        struct foo {
+            struct foo      *next;
+            struct mumble   amumble;
+            int             bar;
+        };
+        /* type starts on column 5, name on column 21 */
+
+
+Switch alignment
+----------------
+
+Align the ``switch`` keyword and the corresponding ``case`` and ``default``
+keywords to the same column. For example:
+
+.. code-block:: c
+
+      switch (alphabet) {
+      case 'a':
+      case 'b':
+          printf("I am a or b\n");
+          break;
+      default:
+          break;
+      }
+
+
+Naming
+======
+
+- Use ``snake_case`` for the names of variables, functions, and files.
+- Use your own judgement when you name variables and be as spartan as possible,
+  abbreviation is common in C.
+  For example, do not use a name like ``this_variable_is_a_temporary_counter``.
+
+
+Types
+=====
+
+- For variables of the following types:
+
+  - ``int``
+  - ``char``
+  - ``short``
+  - ``long``
+
+  Prefer the following types declared in the ``<stdint.h>`` header:
+
+  - ``int8_t``
+  - ``uint8_t``
+  - ``int16_t``
+  - ``uint16_t``
+  - ``int32_t``
+  - ``uint32_t``
+  - ``int64_t``
+  - ``uint64_t``
+
+  The latter types give us more predictable value range and memory layout on
+  different platforms.
+
+- Use the `bool` type for boolean data. You have to include the ``<stdbool.h>``
+  header.
+- Always use the ``size_t`` type when you work with:
+
+  - Sizes of objects
+  - Memory ranges
+
+
+Line length
+===========
+
+- Limit each line to 80 columns or less.
+- If you have to wrap a longer statement, put the operator at the end of the
+  line and use **eight** spaces to indent the next line. Indentation on the
+  next level is not affected. For example:
+
+  .. code-block:: c
+
+        while (cnt < 20 && this_variable_name_is_too_long &&
+                ep != NULL) {
+            z = a + really + long + statement + that + needs +
+                    two + lines + gets + indented + four + spaces +
+                    on + the + second + and + subsequent + lines;
+        }
+
+  and:
+
+  .. code-block:: c
+
+    int a = function(param_a, param_b, param_c, param_d, param_e, param_f,
+            param_g, param_h, param_i, param_j, param_k, param_l);
+
+
+Braces
+======
+
+- Always use braces for all conditional blocks (``if``, ``switch``, ``for``,
+  ``while``, and ``do``), even for single statement conditional blocks (remember
+  the ``goto fail`` bug by Apple?). For example:
+
+  .. code-block:: c
+
+        if (cond) {
+            stmt;
+        }
+
+- For non-function statement blocks, put the opening brace at the end of the
+  first line and the closing brace in a new line. For example:
+
+  .. code-block:: c
+
+        if (x) {
+            foo();
+        }
+
+- For functions, put the opening brace at the beginning of the second line
+  and the closing brace in a new line. For example:
+
+  .. code-block:: c
+
+        int
+        function(int x)
+        {
+            body of the function
+        }
+
+- Place the closing brace in its own line, except when it is part of the same
+  statement, such as a ``while`` in a ``do``-statement or an ``else`` in
+  an ``if``-statement. For example:
+
+  .. code-block:: c
+
+        do {
+            body of do-loop
+        } while (condition);
+
+        and,
+
+        if (x == y) {
+            ..
+        } else if (x > y) {
+            ...
+        } else {
+            ....
+        }
+
+
+Infinite loops
+=============
+
+Create infinite loops with ``for`` statements, not ``while`` statements.
+For example:
+
+.. code-block:: c
+
+      for (;;) {
+          stmt;
+      }
+
+
+Spaces
+======
+
+- Do not use a space after a function name.
+- Use space after keywords, except after the ``sizeof``, ``typeof``, ``alignof``
+  and ``__attribute__`` keywords, since they are used like functions.
+- Do not add spaces inside parenthesized expressions. For example:
+
+  .. code-block:: c
+
+        s = sizeof( sizeof(*p)) ); /* Bad example */
+        s = sizeof(sizeof(*p)); /* Good example */
+
+- When declaring pointers, place the asterisk ('*'') adjacent to the variable
+  name, not the type name. For example:
+
+  .. code-block:: c
+
+        int
+        function(int *p)
+        {
+            char *p;
+            body of the function
+        }
+
+- Use one space around most binary and ternary operators, such as any of these:
+
+  ``=``  ``+``  ``-``  ``<``  ``>``  ``*``  ``/``  ``%``  ``|``  ``&`` ``^``
+  ``<=``  ``>=``  ``==``  ``!=``  ``?``  ``:``
+
+  Do not add spaces after unary operators:
+
+  ``&``  ``*``  ``+``  ``-``  ``~``  ``!``  ``sizeof``  ``typeof``  ``alignof``
+  ``__attribute__``  ``defined``
+
+  Do not add spaces before the postfix increment and decrement unary operators:
+
+  ``++``  ``--``
+
+  Do not add spaces around the ``.`` and ``->`` structure member operators.
+
+- Do not add spaces after casts. For example:
+
+  .. code-block:: c
+
+        int q = *(int *)&p
+
+
+Type definitions
+================
+
+In general, do not use ``typedef`` for the purpose of hiding structures.
+Typedefs used this way are problematic because they do not properly hide their
+underlying type; for example, you need to know if the typedef is the structure
+itself or a pointer to the structure. In addition, they must be declared exactly
+once, whereas an incomplete structure type can be mentioned as many times as
+necessary. Typedefs are difficult to use in stand-alone header files: the header
+that defines the typedef must be included before the header that uses it, or by
+the header that uses it (which causes namespace pollution), or there must be a
+back-door mechanism for obtaining the typedef.
+
+That said, ``typedef`` can be helpful sometimes. For example, it is routinely
+used to clarify the nature of an argument or return value, which can be of a
+rather generic type such as ``void *``. It is also common to rename ``enum``.
+
+To make ``typedef`` names more informative and regular, we use the following
+suffixes:
+
+ - ``_e`` for ``enum``
+ - ``_f`` for floating point numbers, regardless of size
+ - ``_i`` for signed integers, regardless of size
+ - ``_u`` for unsigned integers, regardless of size
+ - ``_fn`` for function pointers
+ - ``_p`` for other pointer type
+ - ``_st`` for ``struct``
+
+
+Forward Declaration
+===================
+
+Prefer using forward declaration over including another header for type-
+declaration only. Forward declaration such as ``struct request;`` is feasible
+if none of its members are directly accessed, such as when it's used in function
+declaration.
+
+
+Functions
+=========
+
+- Declare functions that are local to a file as static.
+- Place function types in their own line preceding the function. For example:
+
+  .. code-block:: c
+
+        static char *
+        function(int a1, int a2, float fl, int a4)
+        {
+            ...
+
+- Separate two successive functions with one blank line.
+- Include parameter names with their dataypes in the function declaration. For
+  example:
+
+  .. code-block:: c
+
+        void function(int param);
+
+- When you use a wrapper function, name the wrapped function with the same name
+  as the wrapper function preceded by an underscore ('_'). Wrapped functions
+  are usually static. For example:
+
+  .. code-block:: c
+
+        static int
+        _fib(int n)
+        {
+            ...
+        }
+
+        int
+        fib(int n)
+        {
+            ...
+            _fib(n);
+            ...
+        }
+
+- Create functions that are short and sweet. Functions should do just one
+  thing and fit on one or two screenfuls of text (80x24 screen size).
+
+  The maximum length of a function is inversely proportional to the
+  complexity and indentation level of that function. So, if you have a
+  conceptually simple function that is just one long (but simple)
+  case-statement, where you have to do lots of small things for many
+  different cases, it is acceptable to have a longer function.
+
+  Another measure of function complexity is the number of local variables. They
+  should not exceed 5-10. If your function has more than that, re-think the
+  function and split it into smaller pieces. A human brain can
+  generally easily keep track of about seven different things; anything more
+  and it gets confused. You may need to come back to your function and
+  understand what you did two weeks from now.
+
+
+Goto statements
+===============
+
+- Use ``goto`` statements judiciously. Never use them to jump out of the
+  current function. Almost the only case where ``goto`` statements are helpful
+  is when a flow can exit from multiple locations within a function, and the
+  same clean-up logic applies to all of them.
+
+
+  .. code-block:: c
+
+        int
+        fun(void)
+        {
+            int result = 0;
+            char *buffer;
+            buffer = malloc(1024);
+            if (buffer == NULL) {
+                return -1;
+            }
+            if (condition1) {
+                while (loop1) {
+                    ...
+                }
+                result = 1;
+                goto out;
+            }
+            ...
+        out:
+            free(buffer);
+            return result;
+        }
+
+
+
+Comments
+========
+
+- Do not use ``//`` for single line comments. Instead, use the ``/* ... */``
+  style.
+
+- For multi-line comments, use the following style:
+
+  .. code-block:: c
+
+        /*
+         * This is the preferred style for multi-line
+         * comments in the Linux kernel source code.
+         * Please use it consistently.
+         *
+         * Description:  A column of asterisks on the left side,
+         * with beginning and ending almost-blank lines.
+         */
+
+- To comment out blocks of code spanning several lines, use
+  ``#ifdef 0 ... #endif``.
+
+- Add comments before all major functions to describe what they do. Do not put
+  comments in the function body unless absolutely needed. For example:
+
+  .. code-block:: c
+
+        /*
+         * Try to acquire a physical address lock while a pmap is locked.  If we
+         * fail to trylock we unlock and lock the pmap directly and cache the
+         * locked pa in *locked.  The caller should then restart their loop in
+         * case the virtual to physical mapping has changed.
+         */
+        int
+        vm_page_pa_tryrelock(pmap_t pmap, vm_paddr_t pa, vm_paddr_t *locked)
+        {
+            ...
+
+
+
+Other naming conventions
+========================
+
+- Use UPPERCASE for macro names.
+
+- Use ``enum`` to define several related constants. Use UPPERCASE for all
+  enumeration values.
+
+- Avoid macros as much as possible and use inline functions wherever you can.
+
+- For macros encapsulating compound statements, right-justify the backslashes
+  and enclose the statements in a ``do { ... } while (0)`` block.
+
+- For parameterized macros, add parentheses to all the parameters. For example:
+
+  .. code-block:: c
+
+        #define ADD_1(x) ((x) + 1)
+
+
+
+Inclusion
+=========
+
+- Rule of thumb- local to global: first include header of the same name as
+  source, followed by headers in the same project, and external/system headers
+  last.
+- Organize header inclusion in blocks, separated by blank line(s). For example,
+  headers that are shipped with the project and system headers should be in
+  separate clusters.
+- Sort inclusions within the same block in alphabetic order.
+
+  .. code-block:: c
+
+        /* File: foo.c */
+        #include "foo.h" /* first block: own header */
+
+        #include "bar.h" /* second block: headers from current project */
+        #include "util/baz.h"
+
+        #include <stdbool.h> /* third block: system/library headers */
+        #include <stdint.h>
+        #include <stdlib.h>
+
+
+Structures
+==========
+
+- To determine the size of a data structure, use some data of that type instead
+  of the type itself. For example:
+
+  .. code-block:: c
+
+        char *p;
+        p = malloc(sizeof(*p));   /* Good example */
+        p = malloc(sizeof(char)); /* Bad example */
+
+- Declare each variable in a structure in a separate line. Try to make the
+  structure readable by aligning the member names and comments using spaces.
+  Use a modest number of spaces if they suffice to align most of the member
+  names. Separate names that follow extremely long types with a single space.
+
+  .. code-block:: c
+
+        struct foo {
+            struct foo    *next;   /* List of active foo. */
+            struct mumble amumble; /* Comment for mumble. */
+            int           bar;     /* Try to align the comments. */
+            struct verylongtypename *baz; /* Won't fit in 2 tabs. */
+        };
+        struct foo *foohead;    /* Head of global foo list. */
+
+- Declare major structures at the top of the file in which they are used, or
+  in separate header files if they are used in multiple source files.
+  Use of the structures should be by separate declarations and should be
+  ``extern`` if they are declared in a header file.
+
+
+Pointers
+========
+
+- Use ``NULL`` as the null pointer constant (instead of ``0``).
+
+- Compare pointers to ``NULL``. For example:
+
+  .. code-block:: c
+
+        (p = f()) == NULL
+
+  Do not compare to zero the integer. For example:
+
+  .. code-block:: c
+
+        !(p = f())
+
+- Do not use ``!`` for comparisons (unless the variable is of boolean type). For
+  example:
+
+  .. code-block:: c
+
+        if (*p == '\0')
+
+  The following snippet is a bad example:
+
+  .. code-block:: c
+
+        if (!*p) /* assume p is of type char * */
+
+- Use ``const`` for function parameters if the pointer has no side effect.
+
+- Functions in charge of freeing an object should take a pointer to the intended
+  pointer to be freed, and set the pointer to the object to ``NULL`` before
+  returning. This prevents dangling pointers that are often discovered long
+  after ``free`` is called.
+
+  .. code-block:: c
+
+        void
+        destroy_buffer(struct buffer **pb)
+        {
+            free(*pb);
+            *pb = NULL;
+        }
+
+- Dynamically allocated structures should always initialize their members of
+  pointer type as soon as possible, to avoid the dangling pointer problem.
+
+
+Macros
+======
+
+- Prefer ``static inline`` functions over macros. Macros often have unintended
+  side effects, for example:
+
+  .. code-block:: c
+
+        #define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+  When used as in ``MAX(x++, y++)``, will increment either ``x`` or ``y`` twice,
+  which is probably not intended by the caller.
+
+
+.. rubric:: Footnotes
+
+.. [#fn1] Frederick Brooks gave a definition of "style" in his book, The Design
+   of Design, which begins with "Style is a set of different repeated
+   microdecisions...". The book talked about the importance of Consistency in
+   the pages leading to this definition, starting from page 142, where the
+   author claimed that "consistency underlies all principles of quality".
diff --git a/docs/modules/cc_log.rst b/docs/modules/cc_log.rst
index 122dfe9c1..6a206210f 100644
--- a/docs/modules/cc_log.rst
+++ b/docs/modules/cc_log.rst
@@ -1,23 +1,60 @@
 Log
 ===
 
-The log module provides a pause-less logging utility that incurs very little latency, and works well on latency-sensitive paths. It prioritizes performance over reliability, and is suitable for debug logging, event logging but not transaction logging.
+The log module provides a pause-less logging utility that incurs very little
+latency, and works well on latency-sensitive paths. It prioritizes performance
+over reliability, and is suitable for debug logging, event logging but not
+transaction logging.
 
 Background
 ----------
 
-Logging is the essential in recording important events, abnormal behavior and data samples. Unfortunately, for in-memory cache or other latency-sensitive applications, logging often presents a dilemma for developers. The naive log implementation usually writes directly to a file, an operation that is most likely buffered, but not guaranteed to return immediately. In production, it is not unheard of for a background task that nobody knows about to create contention around disk I/O, and to cause "mysterious" slowdown among mission critical services. As a result, developers often invoke logging somewhat hesitantly, and shy away from high-frequency logging practice such as request recording, fearing the negative impact on core performance.
+Logging is the essential in recording important events, abnormal behavior and
+data samples. Unfortunately, for in-memory cache or other latency-sensitive
+applications, logging often presents a dilemma for developers. The naive log
+implementation usually writes directly to a file, an operation that is most
+likely buffered, but not guaranteed to return immediately. In production, it
+is not unheard of for a background task that nobody knows about to create
+contention around disk I/O, and to cause "mysterious" slowdown among mission
+critical services. As a result, developers often invoke logging somewhat
+hesitantly, and shy away from high-frequency logging practice such as request
+recording, fearing the negative impact on core performance.
 
 Design
 ------
 
-The nature of I/O operations against persistent media means there is always a trade-off between having data stored reliably, and introducing overhead to performance critical processing. For the purpose we are considering here- debug logging, data sampling, etc- we think it is acceptable to give up a little bit of reliability for predictable performance.
-
-The trade-off is made with the consistent use of memory as an intermediate logging destination, a ring buffer that supports a single producer and a single consumer to be exact. A thread on the performance-critical path writes to the ring buffer which always returns immediately. Users are supposed to set up another, asynchronous (background) thread to flush data in the ring buffer from memory to their final location, which is a file. When the buffer becomes full, logged data are dropped until the next flush succeeds.
-
-The rationale for this design comes from a few observations in production: first, when everything is working as expected, the producer/consumer logging setup is actually quite similar to buffered write. Configurable buffer size and flush interval give user some control, and I/O operations are generally more efficient with a larger chunk of contiguous data than many smaller ones, reducing the overall contention at storage devices. Second, when the system is under high load, it is usually a sensible decision to sacrifice log fidelity for maximum application throughput. Finally, if an error condition is triggering abundant exception logging that overwhelms the buffer, it is very likely for the dropped logs to be similar to existing ones. Therefore, we can afford significant data loss/drop without losing much insight into the problem. The last condition is also helped if high-performance metrics are used to provide robust statistics.
-
-We have retained the ability to log directly to a file with the right configuration options, which are explained below. We recognize that it is nice to have a straightforward way of logging that does not require much setup, e.g. a background thread, for development or more relaxed scenarios.
+The nature of I/O operations against persistent media means there is always a
+trade-off between having data stored reliably, and introducing overhead to
+performance critical processing. For the purpose we are considering here-
+debug logging, data sampling, etc- we think it is acceptable to give up a
+little bit of reliability for predictable performance.
+
+The trade-off is made with the consistent use of memory as an intermediate
+logging destination, a ring buffer that supports a single producer and a
+single consumer to be exact. A thread on the performance-critical path writes
+to the ring buffer which always returns immediately. Users are supposed to set
+up another, asynchronous (background) thread to flush data in the ring buffer
+from memory to their final location, which is a file. When the buffer becomes
+full, logged data are dropped until the next flush succeeds.
+
+The rationale for this design comes from a few observations in production:
+first, when everything is working as expected, the producer/consumer logging
+setup is actually quite similar to buffered write. Configurable buffer size
+and flush interval give user some control, and I/O operations are generally
+more efficient with a larger chunk of contiguous data than many smaller ones,
+reducing the overall contention at storage devices. Second, when the system is
+under high load, it is usually a sensible decision to sacrifice log fidelity
+for maximum application throughput. Finally, if an error condition is
+triggering abundant exception logging that overwhelms the buffer, it is very
+likely for the dropped logs to be similar to existing ones. Therefore, we can
+afford significant data loss/drop without losing much insight into the problem.
+The last condition is also helped if high-performance metrics are used to
+provide robust statistics.
+
+We have retained the ability to log directly to a file with the right
+configuration options, which are explained below. We recognize that it is nice
+to have a straightforward way of logging that does not require much setup, e.g.
+a background thread, for development or more relaxed scenarios.
 
 
 Data Structure
@@ -34,7 +71,10 @@ Data Structure
 
 ``log_metrics_st`` declares metrics native to the ``log`` module.
 
-A ``logger`` has three fields: ``name`` points to the name of the log file, which may be ``NULL`` e.g. if using standard outputs; ``fd`` is the file descriptor for the log file; ``buf`` points to the ring buffer used for temporary log storage, buffering is disabled if ``buf`` is set to ``NULL``.
+A ``logger`` has three fields: ``name`` points to the name of the log file,
+which may be ``NULL`` e.g. if using standard outputs; ``fd`` is the file
+descriptor for the log file; ``buf`` points to the ring buffer used for
+temporary log storage, buffering is disabled if ``buf`` is set to ``NULL``.
 
 Synopsis
 --------
@@ -53,7 +93,7 @@ Synopsis
 
   void log_flush(struct logger *logger);
 
-  rstatus_i log_reopen(struct logger *logger);
+  rstatus_i log_reopen(struct logger *logger, char *target);
 
 Description
 -----------
@@ -74,9 +114,17 @@ Create and destroy
   struct logger *log_create(char *filename, uint32_t buf_cap);
   void log_destroy(struct logger **logger);
 
-``log_create`` returns a logger with the information given or ``NULL`` if an error has occurred. If ``filename`` is not ``NULL``, it will attempt to open the file with flags ``O_WRONLY | O_APPEND | O_CREAT`` and masks ``0644``. Otherwise, it defaults the output to ``stderr``. ``log_create`` uses ``buf_cap`` in creating the ring buffer. A buffer of capacity ``buf_cap`` is allocated upon successful return. However, if ``cap_buf`` equals ``0``, buffering is turned off and ``write`` syscall will be used directly.
+``log_create`` returns a logger with the information given or ``NULL`` if an
+error has occurred. If ``filename`` is not ``NULL``, it will attempt to open
+the file with flags ``O_WRONLY | O_APPEND | O_CREAT`` and masks ``0644``.
+Otherwise, it defaults the output to ``stderr``. ``log_create`` uses
+``buf_cap`` in creating the ring buffer. A buffer of capacity ``buf_cap`` is
+allocated upon successful return. However, if ``cap_buf`` equals ``0``,
+buffering is turned off and ``write`` syscall will be used directly.
 
-``log_destroy`` will flush to the log file and release all memory resources whenever applicable. Note that the argument is of type ``struct logger **`` to avoid dangling pointers.
+``log_destroy`` will flush to the log file and release all memory resources
+whenever applicable. Note that the argument is of type ``struct logger **`` to
+avoid dangling pointers.
 
 Write to logger
 ^^^^^^^^^^^^^^^
@@ -87,34 +135,66 @@ Write to logger
   #define log_stdout(...) _log_fd(STDOUT_FILENO, __VA_ARGS__)
   bool log_write(struct logger *logger, char *buf, uint32_t len);
 
-``log_stderr`` and ``log_stdout`` are two convenience wrappers that make it easy to log to standard outputs. The arguments follow the same convention as in ``printf``.
+``log_stderr`` and ``log_stdout`` are two convenience wrappers that make it
+easy to log to standard outputs. The arguments follow the same convention as
+in ``printf``.
 
-``log_write`` takes a formatted string of length ``len`` stored in ``buf``, and logs it according to the way ``logger`` is created. If buffering is enabled, data is copied to the ring buffer. If the ring buffer does not have enough free capacity for the log, the entire log is skipped. Without buffering, ``log_write`` writes directly to the ``fd`` it is setup with in a best-effort fashion.
+``log_write`` takes a formatted string of length ``len`` stored in ``buf``,
+and logs it according to the way ``logger`` is created. If buffering is enabled,
+data is copied to the ring buffer. If the ring buffer does not have enough
+free capacity for the log, the entire log is skipped. Without buffering,
+``log_write`` writes directly to the ``fd`` it is setup with in a best-effort
+fashion.
 
 Flush to file
 ^^^^^^^^^^^^^
 .. code-block:: C
 
-  void log_flush(struct logger *logger);
+  size_t log_flush(struct logger *logger);
 
-``log_flush`` writes as much data to the log file as possible, and updates the (read) marker in the ring buffer. Data that cannot be written to the file will be kept until next call. If the ring buffer or the file was never setup, no action is taken.
+``log_flush`` writes as much data to the log file as possible, and updates the
+(read) marker in the ring buffer. Data that cannot be written to the file will
+be kept until next call. If the ring buffer or the file was never setup, no
+action is taken. Return the number of bytes flushed.
 
 
 Log reopen
 ^^^^^^^^^^
 .. code-block:: C
 
-  rstatus_i log_reopen(struct logger *logger);
+  rstatus_i log_reopen(struct logger *logger, char *target);
 
-``log_reopen`` reopens the log file according to ``name``, and does nothing if standard outputs are used. It returns ``CC_OK`` for success or ``CC_ERROR`` if reopen failed (at which point ``logger`` will no longer have a valid ``fd``).
+``log_reopen`` reopens the log file according to ``name``, and does nothing if
+standard outputs are used. It returns ``CC_OK`` for success or ``CC_ERROR`` if
+reopen failed (at which point ``logger`` will no longer have a valid ``fd``).
+If ``target`` is specified function will rename original log file to the
+provided target filename and reopen the log file.
 
-This function can be used to reopen the log file when an exception has happened, or another party such as ``logrotate`` instructs the application to do so. Log rotation in a ``nocopytruncate`` manner- i.e. the content in the file is not copied, but the file is simply renamed- is more efficient in high-load systems. But doing so requires signaling the application to reopen the log file after renaming. This function makes it possible to achieve that when used with proper signal handling.
+This function can be used to reopen the log file when an exception has happened,
+or another party such as ``logrotate`` instructs the application to do so. Log
+rotation in a ``nocopytruncate`` manner- i.e. the content in the file is not
+copied, but the file is simply renamed- is more efficient in high-load systems.
+But doing so requires signaling the application to reopen the log file after
+renaming. This function makes it possible to achieve that when used with
+proper signal handling.
 
 Thread-safety
 -------------
-The logger is not thread-safe in the general sense. However, it is safe to use one thread as the producer, which writes to the logger, while using another thread as the consumer, which flushes the logger. A typical setup would have a worker thread being the producer and a background maintenance thread as the consumer.
-
-If ``log_reopen`` is used with a signal, it might invalidate the previous file descriptor in the middle of ``log_flush`` execution, regardless of thread model. The impact of this is to see an exception in ``write`` and failure in clearing up the ring buffer. But as long as ``log_flush`` is scheduled periodically, it is not fatal. To avoid such conflict, ``log_reopen`` should be scheduled on the same thread that performs ``log_flush``, and executed sequentially. One way of setting up signals to achieve this behavior requires masking the signal used for log rotation and having the thread check for pending signals using ``sigpending``.
+The logger is not thread-safe in the general sense. However, it is safe to use
+one thread as the producer, which writes to the logger, while using another
+thread as the consumer, which flushes the logger. A typical setup would have a
+worker thread being the producer and a background maintenance thread as the
+consumer.
+
+If ``log_reopen`` is used with a signal, it might invalidate the previous file
+descriptor in the middle of ``log_flush`` execution, regardless of thread model.
+The impact of this is to see an exception in ``write`` and failure in clearing
+up the ring buffer. But as long as ``log_flush`` is scheduled periodically, it
+is not fatal. To avoid such conflict, ``log_reopen`` should be scheduled on
+the same thread that performs ``log_flush``, and executed sequentially. One
+way of setting up signals to achieve this behavior requires masking the signal
+used for log rotation and having the thread check for pending signals using
+``sigpending``.
 
 Examples
 --------
diff --git a/docs/modules/cc_metric.rst b/docs/modules/cc_metric.rst
index bfc6adad0..8ca95c3ac 100644
--- a/docs/modules/cc_metric.rst
+++ b/docs/modules/cc_metric.rst
@@ -1,43 +1,89 @@
 Metrics
 =======
 
-The metrics module provides a light-weight library to declare, update and report metrics.
+The metrics module provides a light-weight library to declare, update and
+report metrics.
 
 
-Metrics can be turned on or off at compile time. They can also be enabled, disabled and composed at the module level. For example, if an application uses both the ``event`` module and ``tcp`` module, it is perfectly fine to disable metrics on the ``event`` module while enabling it for the ``tcp`` module. You only pay for what you use.
+Metrics can be turned on or off at compile time. They can also be enabled,
+disabled and composed at the module level. For example, if an application uses
+both the ``event`` module and ``tcp`` module, it is perfectly fine to disable
+metrics on the ``event`` module while enabling it for the ``tcp`` module. You
+only pay for what you use.
 
-The desire to compose metric groups drives a lot of the design decisions of metrics, as we shall explain below.
+The desire to compose metric groups drives a lot of the design decisions of
+metrics, as we shall explain below.
 
 Background
 ----------
 
-If good abstraction works when it hides as much unnecessary details from users as possible, then good observability plays the complimentary role. Instead of enclosing functionalities in a black box, it offers a glimpse into their internal state and structure. If everything works perfectly, abstraction is all that is needed. However, when things go wrong, as they inevitable do eventually, observability is the first thing developers turn to for monitoring and debugging.
+If good abstraction works when it hides as much unnecessary details from users
+as possible, then good observability plays the complimentary role. Instead of
+enclosing functionalities in a black box, it offers a glimpse into their
+internal state and structure. If everything works perfectly, abstraction is
+all that is needed. However, when things go wrong, as they inevitable do
+eventually, observability is the first thing developers turn to for monitoring
+and debugging.
 
-Good observability is one of the defining properties of production systems, as compared to prototypes and toy systems which often lack it. But because it is orthogonal to the functionalities of the system being built, and often not included in the initial design and implementation, a lot of systems end up having observability that feels bolted on and alien.
+Good observability is one of the defining properties of production systems, as
+compared to prototypes and toy systems which often lack it. But because it is
+orthogonal to the functionalities of the system being built, and often not
+included in the initial design and implementation, a lot of systems end up
+having observability that feels bolted on and alien.
 
 Goals
 -----
 
 Through practice, we found there are a few properties that we really appreciate:
 
-#. metrics should be cheap to update and retrieve, so developers don't have to worry excessively about overhead and performance degradation caused by observability.
-#. there needs to be an easy way to provide and look up the meaning of every metric, so readings can readily translate into understanding and insight.
-#. for reusable modules or libraries, having metrics reported the same way everywhere is highly desirable, so developers know what to look for and can rely on their experiences from elsewhere.
-
-In reality, achieving all these goals at once is often a luxury. For example, many libraries offer no visibility by themselves, forcing developers to create and maintain metrics above the library APIs. This means what's visible is limited by API exposure, which is often less than what the internal states capture. It also means duplicate work among different users. When libraries do provide metrics, they are offered as standalone and cannot be easily combined.
-
-Given the scope of this project, we not only have control over how functionalities are implemented, but also can influence the desirable way of organizing and using these functionalities. In other words, we can afford to dictate how we think observability should be provided. With this assumption, it turns out we can find a way to achieve all these goals at once.
+#. metrics should be cheap to update and retrieve, so developers don't have to
+   worry excessively about overhead and performance degradation caused by
+   observability.
+#. there needs to be an easy way to provide and look up the meaning of every
+   metric, so readings can readily translate into understanding and insight.
+#. for reusable modules or libraries, having metrics reported the same way
+   everywhere is highly desirable, so developers know what to look for and can
+   rely on their experiences from elsewhere.
+
+In reality, achieving all these goals at once is often a luxury. For example,
+many libraries offer no visibility by themselves, forcing developers to create
+and maintain metrics above the library APIs. This means what's visible is
+limited by API exposure, which is often less than what the internal states
+capture. It also means duplicate work among different users. When libraries do
+provide metrics, they are offered as standalone and cannot be easily combined.
+
+Given the scope of this project, we not only have control over how
+functionalities are implemented, but also can influence the desirable way of
+organizing and using these functionalities. In other words, we can afford to
+dictate how we think observability should be provided. With this assumption,
+it turns out we can find a way to achieve all these goals at once.
 
 Design
 ------
 
-Metrics are part of each module. Almost every module comes with a predefined group of metrics that capture its state and usage. This saves developers the trouble of managing metrics at the application level and minimizes duplicate work among similar use cases. Users can follow the same convention to group and define metrics outside of this library, and mix everything together.
-
-A metric groups takes on the dual format of a structure whose members are metrics, and an array whose elements are metrics. This is made possible with the use of C preprocessors, and makes both updating (lookup by name, via the structure interpretation) and reporting (traverse by iteration, via the array interpretation) efficient. Users can further create a global structure containing multiple metrics groups, whiles still using the same flattened array view to process all metrics.
-
-Metrics should be allocated globally, and the address for each module's metric group(s) should be provided during module setup (or ``NULL`` to turn off metrics). This means users have total control of the memory layout of metrics, at the cost of having to setup module up with such information. In practice, this often means global metric reporting is extremely straightforward.
-
-Metrics are updated and reported using atomic instructions, not locks. When combined with zero- or low-contention threading model, metric access is extremely efficient.
+Metrics are part of each module. Almost every module comes with a predefined
+group of metrics that capture its state and usage. This saves developers the
+trouble of managing metrics at the application level and minimizes duplicate
+work among similar use cases. Users can follow the same convention to group
+and define metrics outside of this library, and mix everything together.
+
+A metric groups takes on the dual format of a structure whose members are
+metrics, and an array whose elements are metrics. This is made possible with
+the use of C preprocessors, and makes both updating (lookup by name, via the
+structure interpretation) and reporting (traverse by iteration, via the array
+interpretation) efficient. Users can further create a global structure
+containing multiple metrics groups, whiles still using the same flattened
+array view to process all metrics.
+
+Metrics should be allocated globally, and the address for each module's metric
+group(s) should be provided during module setup (or ``NULL`` to turn off
+metrics). This means users have total control of the memory layout of metrics,
+at the cost of having to setup module up with such information. In practice,
+this often means global metric reporting is extremely straightforward.
+
+Metrics are updated and reported using atomic instructions, not locks. When
+combined with zero- or low-contention threading model, metric access is
+extremely efficient.
 
 Data Structure
 --------------
@@ -61,9 +107,12 @@ Data Structure
       };
   };
 
-``metric`` is the fundamental data structure, each metric has (for now) three types, a printable name, a short description, and value.
+``metric`` is the fundamental data structure, each metric has (for now) three
+types, a printable name, a short description, and value.
 
-If a metric is of type ``METRIC_COUNTER``, its value always increases monotonically. A metric of type ``METRIC_GAUGE`` has a signed integer value. Type ``METRIC_FPN`` means the value is a floating-point number.
+If a metric is of type ``METRIC_COUNTER``, its value always increases
+monotonically. A metric of type ``METRIC_GAUGE`` has a signed integer value.
+Type ``METRIC_FPN`` means the value is a floating-point number.
 
 
 Usage
@@ -77,9 +126,12 @@ Declare and initialize
   METRIC_INIT(_name, _type, _description)
   METRIC_NAME(_name, _type, _description)
 
-To use these macros, ``_name`` *must* be a legal identifier [C11]_. See ``cc_metric.h`` for related implementation details.
+To use these macros, ``_name`` *must* be a legal identifier [C11]_. See
+``cc_metric.h`` for related implementation details.
 
-A C preprocessor convention allows the above macros to be applied against a "list" of metrics. For example, one can define request related metrics, ``REQUEST_METRIC``, as such:
+A C preprocessor convention allows the above macros to be applied against a
+"list" of metrics. For example, one can define request related metrics,
+``REQUEST_METRIC``, as such:
 
 .. code-block:: C
 
@@ -90,7 +142,8 @@ A C preprocessor convention allows the above macros to be applied against a "lis
       ACTION( request_create,     METRIC_COUNTER, "# reqs created"       )\
       ACTION( request_destroy,    METRIC_COUNTER, "# reqs destroyed"     )
 
-A metric group for the request module can be defined by using the ``METRIC_DECLARE`` macro against the list above:
+A metric group for the request module can be defined by using the
+``METRIC_DECLARE`` macro against the list above:
 
 .. code-block:: C
 
@@ -111,10 +164,11 @@ Helper functions
 .. code-block:: C
 
   void metric_reset(struct metric sarr[], unsigned int nmetric);
-  size_t metric_print(char *buf, size_t nbuf, struct metric *m);
+  size_t metric_print(char *buf, size_t nbuf, char *fmt, struct metric *m);
 
 ``metric_reset`` resets the values of an array of metrics.
-``metric_print`` prints the name and value of a metric, in human readable format, to buffer ``buf``, with a single space separating the two fields. This simple style is compatible with how Memcached currently reports metrics ([Memcached]_). Helper functions for other formats (e.g. Redis [Redis]_, StatsD [StatsD]_) may be introduced in the future.
+``metric_print`` prints the name and value of a metric, in human readable
+format specified by ``fmt``, to buffer ``buf``.
 
 
 Update
@@ -127,20 +181,28 @@ Update
   DECR_N(_base, _metric, _delta)
   UPDATE_VAL(_base, _metric, _val)
 
-The ``_base`` field reflects the starting address of the metric group. Therefore, if ``request_metrics`` is of type ``request_metrics_st *``, we can use it and the metric name, e.g. ``request_free`` as listed in ``REQUEST_METRIC`` to update the metric value:
+The ``_base`` field reflects the starting address of the metric group.
+Therefore, if ``request_metrics`` is of type ``request_metrics_st *``, we can
+use it and the metric name, e.g. ``request_free`` as listed in
+``REQUEST_METRIC`` to update the metric value:
 
 .. code-block:: C
 
   DECR(request_metrics, request_free);
 
-``UPDATE_VAL`` applies to all three metric types. ``INCR_N`` and ``INCR``, which is short for ``INCR_N(_, _, 1)``, apply to both counters and gauges. ``DECR_N`` and ``DECR`` apply to gauges only.
+``UPDATE_VAL`` applies to all three metric types. ``INCR_N`` and ``INCR``,
+which is short for ``INCR_N(_, _, 1)``, apply to both counters and gauges.
+``DECR_N`` and ``DECR`` apply to gauges only.
 
 Report
 ^^^^^^
 
-Often, reporting metrics means iterating through and read/print them all. This is when the array view of metrics becomes handy.
+Often, reporting metrics means iterating through and read/print them all. This
+is when the array view of metrics becomes handy.
 
-The object that the aforementioned ``request_metrics`` points to has the same memory layout as an array of ``struct metric``. We only need to know the size of this array to traverse it, which we can get via the following macro:
+The object that the aforementioned ``request_metrics`` points to has the same
+memory layout as an array of ``struct metric``. We only need to know the size
+of this array to traverse it, which we can get via the following macro:
 
 .. code-block:: C
 
@@ -163,7 +225,8 @@ Which helps us to loop through all request related metrics:
 Hierarchical composition
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
-A full-fledged application uses many modules. Similarly, metric groups can be further assembled to provide observability of the entire service:
+A full-fledged application uses many modules. Similarly, metric groups can be
+further assembled to provide observability of the entire service:
 
 .. code-block:: c
 
@@ -173,12 +236,16 @@ A full-fledged application uses many modules. Similarly, metric groups can be fu
       storage_metrics_st      storage_metrics;
   } app_stats;
 
-To work with this setup, individual modules should be initialized with the correct base address of their metric group, e.g. ``&app_stats.storage_metrics`` for the storage module. Reporting multiple metric groups works almost exactly the same as a single metric group.
+To work with this setup, individual modules should be initialized with the
+correct base address of their metric group, e.g.
+``&app_stats.storage_metrics`` for the storage module. Reporting multiple
+metric groups works almost exactly the same as a single metric group.
 
 Compile-time switch
 ^^^^^^^^^^^^^^^^^^^
 
-All macros can be turned to no-op by turning off ``HAVE_STATS`` at compile time, which in turn undefines ``CC_STATS``.
+All macros can be turned to no-op by turning off ``HAVE_STATS`` at compile time
+, which in turn undefines ``CC_STATS``.
 
 .. code-block:: bash
 
diff --git a/docs/modules/cc_option.rst b/docs/modules/cc_option.rst
index ecde3dbe6..38983fe56 100644
--- a/docs/modules/cc_option.rst
+++ b/docs/modules/cc_option.rst
@@ -1,18 +1,37 @@
 Option
 ======
 
-The option module facilitates the declaration, loading and combination of per-module and global configuration options.
+The option module facilitates the declaration, loading and combination of per-
+module and global configuration options.
 
-The ability to compose options minimizes the work developers put into related boilerplate, and keeps naming and default values consistent.
+The ability to compose options minimizes the work developers put into related
+boilerplate, and keeps naming and default values consistent.
 
 Background
 ----------
 
-Every service needs some amount of configuration. While hugely useful and necessary, code that does configuration is mostly boilerplate and isn't exactly fun to write. Furthermore, reusing libraries or modules often does not spare the developers from creating and passing along aggregated options for these components, repeated for each service or application. Such boilerplate thus often takes a large code footprint among application-specific logic despite being mundane.
-
-When it comes to the format of configuration, there are flavors and varieties. Most notable is the choice of using primarily command line options or config files. In general, command line options are easier and quicker to start with, making them great for testing and development. However, they become less manageable as the number of options increases. And as part of the command that launched the process, they are potentially confusing if applications ever want config-reload support. Config files work better if a large of tuning knobs are present and commonly used, or when it is desirable to keep history or share configurations. On the downside, an extra file is used.
-
-Within each route there are also varieties. Several conventions exist for command line, such as short vs long name, single or double dash prefix. For config files, many languages and/or formats have been used, such as YAML, XML, and numerous simpler formats created ad hoc by the developers.
+Every service needs some amount of configuration. While hugely useful and
+necessary, code that does configuration is mostly boilerplate and isn't exactly
+fun to write. Furthermore, reusing libraries or modules often does not spare the
+developers from creating and passing along aggregated options for these
+components, repeated for each service or application. Such boilerplate thus often
+takes a large code footprint among application-specific logic despite being
+mundane.
+
+When it comes to the format of configuration, there are flavors and varieties.
+Most notable is the choice of using primarily command line options or config
+files. In general, command line options are easier and quicker to start with,
+making them great for testing and development. However, they become less
+manageable as the number of options increases. And as part of the command that
+launched the process, they are potentially confusing if applications ever want
+config-reload support. Config files work better if a large of tuning knobs are
+present and commonly used, or when it is desirable to keep history or share
+configurations. On the downside, an extra file is used.
+
+Within each route there are also varieties. Several conventions exist for
+command line, such as short vs long name, single or double dash prefix. For
+config files, many languages and/or formats have been used, such as YAML, XML,
+and numerous simpler formats created ad hoc by the developers.
 
 Goals
 -----
@@ -25,13 +44,33 @@ We want to have configuration options that:
 Design
 ------
 
-Options are part of each module, declared with macro with a table-like layout. Information of each option include name, type, default value, and description. They can be combined and manipulated with other macros and functions.
-
-Options are grouped and viewed in two ways: as members of a higher-level struct, or elements in an array. The former makes it easy to access individual option by name, such as passing the right options to initialize a specific module. The latter facilitates option traversal, which is useful to print all the options available and their default/current values.
-
-We opt for a file-oriented approach to pass most options into an application. Our estimate of the number of options in the services we want to create makes config files the more readable choice, and it paves way for dynamic reload.
-
-The format within the config file needs to balance a few things: expressiveness, human readability, and parsing complexity. We researched a few existing solutions: JSON, YAML, Java's simple Option class, whitespace delimiter-ed options used by Redis, etc. Looking at the needs of our target application group, as represented by Memcached and Redis, it seems the simple key value is either sufficient or "almost sufficient". Thus we choose to use a key/value format, ``<KEY>: <VALUE>`` (colon and space ``: ``), which happens to be the YAML mappings format. We also adopted the YAML comment that begins with ``#``. It is quite trivial to write a parser for these basic structures from scratch. And being YAML-compatible makes two other things possible: 1) loading the config file by any YAML parser, and 2) extending the config format by borrowing more from the YAML protocol or even using a full-fledged YAML library, if ever needed.
+Options are part of each module, declared with macro with a table-like layout.
+Information of each option include name, type, default value, and description.
+They can be combined and manipulated with other macros and functions.
+
+Options are grouped and viewed in two ways: as members of a higher-level
+struct, or elements in an array. The former makes it easy to access individual
+option by name, such as passing the right options to initialize a specific
+module. The latter facilitates option traversal, which is useful to print all
+the options available and their default/current values.
+
+We opt for a file-oriented approach to pass most options into an application.
+Our estimate of the number of options in the services we want to create makes
+config files the more readable choice, and it paves way for dynamic reload.
+
+The format within the config file needs to balance a few things: expressiveness,
+human readability, and parsing complexity. We researched a few existing
+solutions: JSON, YAML, Java's simple Option class, whitespace delimiter-ed
+options used by Redis, etc. Looking at the needs of our target application
+group, as represented by Memcached and Redis, it seems the simple key value is
+either sufficient or "almost sufficient". Thus we choose to use a key/value
+format, ``<KEY>: <VALUE>`` (colon and space ``: ``), which happens to be the
+YAML mappings format. We also adopted the YAML comment that begins with ``#``.
+It is quite trivial to write a parser for these basic structures from scratch.
+And being YAML-compatible makes two other things possible: 1) loading the
+config file by any YAML parser, and 2) extending the config format by
+borrowing more from the YAML protocol or even using a full-fledged YAML library,
+if ever needed.
 
 Data Structure
 --------------
@@ -40,6 +79,7 @@ Data Structure
   typedef enum option_type {
       OPTION_TYPE_BOOL,
       OPTION_TYPE_UINT,
+      OPTION_TYPE_FPN,
       OPTION_TYPE_STR,
       OPTION_TYPE_SENTINEL
   } option_type_e;
@@ -47,6 +87,7 @@ Data Structure
   typedef union option_val {
       bool vbool;
       uintmax_t vuint;
+      double vfpn;
       char *vstr;
   } option_val_u;
 
@@ -59,7 +100,13 @@ Data Structure
       char *description;
   };
 
-The core data structure ``struct option`` has six members. ``name`` and ``description`` help identify and explain the purpose of the option. ``type`` decides how input should be interpreted, which currently can be boolean, unsigned integer or C string. Both the default value and current value are kept around, with values matching the type. Keeping the default separately will make it easy to reset the option to original. Finally, boolean ``set`` tells if an option has been set, and thus usable.
+The core data structure ``struct option`` has six members. ``name`` and ``
+description`` help identify and explain the purpose of the option. ``type``
+decides how input should be interpreted, which currently can be boolean,
+unsigned integer, double or C string. Both the default value and current value
+are kept around, with values matching the type. Keeping the default separately
+will make it easy to reset the option to original. Finally, boolean ``set``
+tells if an option has been set, and thus usable.
 
 Synopsis
 --------
@@ -71,8 +118,8 @@ Synopsis
   rstatus_i option_load_file(FILE *fp, struct option options[], unsigned int nopt);
 
   void option_print(struct option *opt);
-  void option_printall(struct option options[], unsigned int nopt);
-  void option_printall_default(struct option options[], unsigned int nopt);
+  void option_print_all(struct option options[], unsigned int nopt);
+  void option_describe_all(struct option options[], unsigned int nopt);
 
   void option_free(struct option options[], unsigned int nopt);
 
@@ -86,9 +133,12 @@ Declare and initialize
   #define OPTION_DECLARE(_name, _type, _default, _description)
   #define OPTION_INIT(_name, _type, _default, _description)
 
-To use these macros, ``_name`` *must* be a legal identifier [C11]_. See ``cc_option.h`` for related implementation details.
+To use these macros, ``_name`` *must* be a legal identifier [C11]_. See
+``cc_option.h`` for related implementation details.
 
-A C preprocessor convention allows the above macros to be applied against a "list" of options. For example, one can define options, ``BUF_OPTION``, for a buffer module as such:
+A C preprocessor convention allows the above macros to be applied against a
+"list" of options. For example, one can define options, ``BUF_OPTION``, for a
+buffer module as such:
 
 .. code-block:: C
 
@@ -96,7 +146,8 @@ A C preprocessor convention allows the above macros to be applied against a "lis
       ACTION( buf_init_size,  OPTION_TYPE_UINT,   BUF_DEFAULT_SIZE,   "default size when buf is created" )\
       ACTION( buf_poolsize,   OPTION_TYPE_UINT,   BUF_POOLSIZE,       "buf pool size"                    )
 
-An option struct for the buffer module can be defined by using the ``OPTION_DECLARE`` macro against the list above:
+An option struct for the buffer module can be defined by using the
+``OPTION_DECLARE`` macro against the list above:
 
 .. code-block:: C
 
@@ -118,8 +169,8 @@ Print option info
 .. code-block:: C
 
   void option_print(struct option *opt);
-  void option_printall(struct option options[], unsigned int nopt);
-  void option_printall_default(struct option options[], unsigned int nopt);
+  void option_print_all(struct option options[], unsigned int nopt);
+  void option_describe_all(struct option options[], unsigned int nopt);
 
 
 Examples
diff --git a/docs/modules/cc_ring_array.rst b/docs/modules/cc_ring_array.rst
index 1b8b36654..e4c618baa 100644
--- a/docs/modules/cc_ring_array.rst
+++ b/docs/modules/cc_ring_array.rst
@@ -1,9 +1,15 @@
 ring array
 ==========
 
-Ring array is a circular array data structure that allows elements to be pushed/popped in FIFO order. This data structure is designed to facilitate the sharing of resources between two threads with a producer/consumer relationship; that is, one thread only pushes to the ring array and the other thread only pops from it.
+Ring array is a circular array data structure that allows elements to be
+pushed/popped in FIFO order. This data structure is designed to facilitate the
+sharing of resources between two threads with a producer/consumer relationship;
+that is, one thread only pushes to the ring array and the other thread only pops
+from it.
 
-The main difference between ring array and ring buffer is that the former organizes and processes data as elements, while the latter treats data as flexible-length binary string.
+The main difference between ring array and ring buffer is that the former
+organizes and processes data as elements, while the latter treats data as
+flexible-length binary string.
 
 Synopsis
 --------
@@ -26,7 +32,8 @@ Synopsis
 Description
 -----------
 
-This section contains descriptions of what the functions in the ccommon ring array module do.
+This section contains descriptions of what the functions in the ccommon ring
+array module do.
 
 Creation/Destruction
 ^^^^^^^^^^^^^^^^^^^^
@@ -35,9 +42,15 @@ Creation/Destruction
    struct ring_array *ring_array_create(size_t elem_size, uint32_t cap);
    void ring_array_destroy(struct ring_array **arr);
 
-In order to create a ccommon ``ring_array`` data structure, call ``ring_array_create()`` with ``elem_size`` as the ``sizeof`` the elements the ``ring_array`` contains and with ``cap`` as the maximum number of elements the ``ring_array`` should be able to hold. This function returns a pointer to the ``ring_array`` that it creates.
+In order to create a ccommon ``ring_array`` data structure, call
+``ring_array_create()`` with ``elem_size`` as the ``sizeof`` the elements the
+``ring_array`` contains and with ``cap`` as the maximum number of elements the
+``ring_array`` should be able to hold. This function returns a pointer to the
+``ring_array`` that it creates.
 
-After the ``ring_array`` is no longer needed, ``ring_array_destroy`` should be called with the ``ring_array`` as its argument to free the memory allocated for it.
+After the ``ring_array`` is no longer needed, ``ring_array_destroy`` should be
+called with the ``ring_array`` as its argument to free the memory allocated for
+it.
 
 Element Access
 ^^^^^^^^^^^^^^
@@ -46,9 +59,17 @@ Element Access
    rstatus_i ring_array_push(const void *elem, struct ring_array *arr);
    rstatus_i ring_array_pop(void *elem, struct ring_array *arr);
 
-These functions are used to push/pop elements in the ``ring_array``. To push an element into the ``ring_array``, call ``ring_array_push()`` with ``elem`` being a pointer to the element being stored and ``arr`` being the ``ring_array`` being pushed to. ``ring_array_push()`` returns ``CC_OK`` if the element is stored, and ``CC_ERROR`` if the element could not be stored (i.e. the ``ring_array`` is full).
+These functions are used to push/pop elements in the ``ring_array``. To push an
+element into the ``ring_array``, call ``ring_array_push()`` with ``elem`` being
+a pointer to the element being stored and ``arr`` being the ``ring_array`` being
+pushed to. ``ring_array_push()`` returns ``CC_OK`` if the element is stored, and
+``CC_ERROR`` if the element could not be stored i.e. the ``ring_array`` is full.
 
-To pop an element from the ``ring_array``, call ``ring_array_pop()`` with ``elem`` being a pointer to the memory location for where the element should be popped to, and ``arr`` being the ``ring_array`` being popped from. ``ring_array_pop()`` returns ``CC_OK`` if the element was successfully popped, and ``CC_ERROR`` if not successful (i.e. the ``ring_array`` is empty).
+To pop an element from the ``ring_array``, call ``ring_array_pop()`` with
+``elem`` being a pointer to the memory location for where the element should be
+popped to, and ``arr`` being the ``ring_array`` being popped from.
+``ring_array_pop()`` returns ``CC_OK`` if the element was successfully popped,
+and ``CC_ERROR`` if not successful (i.e. the ``ring_array`` is empty).
 
 State
 ^^^^^
@@ -56,20 +77,26 @@ State
    bool ring_array_full(const struct ring_array *arr);
    bool ring_array_empty(const struct ring_array *arr);
 
-These functions tell the caller about the state of the ``ring_array``, specifically whether it is full or empty. In a producer/consumer model, ``ring_array_full()`` is a producer facing API, and ``ring_array_empty()`` is a consumer facing API. This is so that the producer can check whether or not the ``ring_array`` is full before pushing more elements into the array; likewise, the consumer can check whether or not the ``ring_array`` is empty before attempting to pop.
+These functions tell the caller about the state of the ``ring_array``,
+specifically whether it is full or empty. In a producer/consumer model,
+``ring_array_full()`` is a producer facing API, and ``ring_array_empty()`` is a
+consumer facing API. This is so that the producer can check whether or not the
+``ring_array`` is full before pushing more elements into the array; likewise, the
+consumer can check whether or not the ``ring_array`` is empty before attempting
+to pop.
 
 Flush
 ^^^^^
 ..code-block:: C
    void ring_array_flush(struct ring_array *arr);
 
-This function is a consumer facing API that discards everything in the ``ring_array``.
+This function is an external API that discards everything in the ``ring_array``.
 
 
 Examples
 --------
 
-Multi threaded Hello World! with ccommon ``ring_array``:
+Multi threaded ``Hello World!`` with ccommon ``ring_array``:
 
 .. code-block:: c
 
diff --git a/docs/overview.rst b/docs/overview.rst
index a029e3bd0..47ebc0092 100644
--- a/docs/overview.rst
+++ b/docs/overview.rst
@@ -5,27 +5,47 @@ Overview
 Background
 ==========
 
-Building a Cache Common library has a lot to do with the historical context that gave rise to the idea. The current open-source caching field is both sparse and crowded- most of what people use today trace back to either Memcached or Redis, maybe forked over them. On the other hand, many of the customization and improvement individuals come up with don't make their way back into the trunk version very easily, indicating an architectural problem with the original codebases.
-
-Fundamentally, there hasn't been enough modularity in either project, or the many that derived from them, to encourage sharing and reuse. During our own, multiple attempts to create Twemperf, Twemproxy, Fatcache and Slimcache, regardless of whether we were writing a server, a proxy or a client, we had to resort to copy-and-paste, and littered our changes across the landscape.
-
-It certainly *feels* that there was a lot in common among these projects, so we formalized it by abstracting the commonality as modules and putting them in a single library, which is ccommon, short for Cache Common.
-
-We went through the existing code bases that have implemented some or all of the core functionalities and have been tested in production for years, synthesized them, made changes whenever necessary, to make the APIs generic enough for all the use cases we know of. Inheriting code makes it faster and more reliable to build the library; holding the APIs against known implementations allow the core library to be generic and flexible enough for our needs.
-
-Given that multi-threaded programs are much harder to get right than their single-threaded counterpart, and sometimes incur non-trivial synchronization overhead, the priority is to get single-threading right first, with the possibility of investing in multi-threading in the future on a module-by-module basis.
+Building a Cache Common library has a lot to do with the historical context that
+gave rise to the idea. The current open-source caching field is both sparse and
+crowded- most of what people use today trace back to either Memcached or Redis,
+maybe forked over them. On the other hand, many of the customization and
+improvement individuals come up with don't make their way back into the trunk
+version very easily, indicating an architectural problem with the original
+codebases.
+
+Fundamentally, there hasn't been enough modularity in either project, or the
+many that derived from them, to encourage sharing and reuse. During our own,
+multiple attempts to create Twemperf, Twemproxy, Fatcache and Slimcache,
+regardless of whether we were writing a server, a proxy or a client, we had to
+resort to copy-and-paste, and littered our changes across the landscape.
+
+It certainly *feels* that there was a lot in common among these projects, so we
+formalized it by abstracting the commonality as modules and putting them in a
+single library, which is ccommon, short for Cache Common.
+
+We went through the existing code bases that have implemented some or all of the
+core functionalities and have been tested in production for years, synthesized
+them, made changes whenever necessary, to make the APIs generic enough for all
+the use cases we know of. Inheriting code makes it faster and more reliable to
+build the library; holding the APIs against known implementations allow the core
+library to be generic and flexible enough for our needs.
+
+Given that multi-threaded programs are much harder to get right than their
+single-threaded counterpart, and sometimes incur non-trivial synchronization
+overhead, the priority is to get single-threading right first, with the
+possibility of investing in multi-threading in the future on a module-by-module
+basis.
 
 
 Goals
 =====
 
 #. Modularized functionality with consistent, intuitive interface.
-   
-#. Use abstraction to allow compile-time choice from multiple implementations of the same interface, but avoid excessive, multi-layered abstraction unless absolutely necessary.
-
-#. Production quality code that has built-in configuration, monitoring and logging support.
-
-
+#. Use abstraction to allow compile-time choice from multiple implementations of
+   the same interface, but avoid excessive, multi-layered abstraction unless
+   absolutely necessary.
+#. Production quality code that has built-in configuration, monitoring and
+   logging support.
 #. Work well on platforms emerging in the next 3-5 years.
 
 
diff --git a/include/buffer/cc_buf.h b/include/buffer/cc_buf.h
index 4fe111dd3..279be3d89 100644
--- a/include/buffer/cc_buf.h
+++ b/include/buffer/cc_buf.h
@@ -38,25 +38,25 @@ extern "C" {
 
 
 /*          name            type                default             description */
-#define BUF_OPTION(ACTION)                                                                              \
-    ACTION( buf_init_size,  OPTION_TYPE_UINT,   BUF_DEFAULT_SIZE,   "default size when buf is created" )\
-    ACTION( buf_poolsize,   OPTION_TYPE_UINT,   BUF_POOLSIZE,       "buf pool size"                    )
+#define BUF_OPTION(ACTION)                                                                       \
+    ACTION( buf_init_size,  OPTION_TYPE_UINT,   BUF_DEFAULT_SIZE,   "init buf size incl header" )\
+    ACTION( buf_poolsize,   OPTION_TYPE_UINT,   BUF_POOLSIZE,       "buf pool size"             )
 
 typedef struct {
     BUF_OPTION(OPTION_DECLARE)
 } buf_options_st;
 
 /*          name              type            description */
-#define BUF_METRIC(ACTION)                                              \
-    ACTION( buf_curr,         METRIC_GAUGE,   "# buf allocated"        )\
-    ACTION( buf_active,       METRIC_GAUGE,   "# buf in use/borrowed"  )\
-    ACTION( buf_create,       METRIC_COUNTER, "# buf creates"          )\
-    ACTION( buf_create_ex,    METRIC_COUNTER, "# buf create exceptions")\
-    ACTION( buf_destroy,      METRIC_COUNTER, "# buf destroys"         )\
-    ACTION( buf_borrow,       METRIC_COUNTER, "# buf borrows"          )\
-    ACTION( buf_borrow_ex,    METRIC_COUNTER, "# buf borrow exceptions")\
-    ACTION( buf_return,       METRIC_COUNTER, "# buf returns"          )\
-    ACTION( buf_memory,       METRIC_GAUGE,   "memory allocated to buf")
+#define BUF_METRIC(ACTION)                                                              \
+    ACTION( buf_curr,         METRIC_GAUGE,   "# buf allocated"                        )\
+    ACTION( buf_active,       METRIC_GAUGE,   "# buf in use/borrowed"                  )\
+    ACTION( buf_create,       METRIC_COUNTER, "# buf creates"                          )\
+    ACTION( buf_create_ex,    METRIC_COUNTER, "# buf create exceptions"                )\
+    ACTION( buf_destroy,      METRIC_COUNTER, "# buf destroys"                         )\
+    ACTION( buf_borrow,       METRIC_COUNTER, "# buf borrows"                          )\
+    ACTION( buf_borrow_ex,    METRIC_COUNTER, "# buf borrow exceptions"                )\
+    ACTION( buf_return,       METRIC_COUNTER, "# buf returns"                          )\
+    ACTION( buf_memory,       METRIC_GAUGE,   "memory alloc'd to buf including header" )
 
 typedef struct {
     BUF_METRIC(METRIC_DECLARE)
@@ -68,7 +68,7 @@ struct buf {
     char              *wpos;    /* write marker */
     char              *end;     /* end of buffer */
     bool              free;     /* is this buf free? */
-    char              begin[1]; /* beginning of buffer */
+    char              begin[];  /* beginning of buffer */
 };
 
 #define BUF_HDR_SIZE       offsetof(struct buf, begin)
@@ -103,7 +103,7 @@ void buf_destroy(struct buf **buf);
 
 /* Size of data that has yet to be read */
 static inline uint32_t
-buf_rsize(struct buf *buf)
+buf_rsize(const struct buf *buf)
 {
     ASSERT(buf->rpos <= buf->wpos);
 
@@ -112,37 +112,38 @@ buf_rsize(struct buf *buf)
 
 /* Amount of room left in buffer for writing new data */
 static inline uint32_t
-buf_wsize(struct buf *buf)
+buf_wsize(const struct buf *buf)
 {
     ASSERT(buf->wpos <= buf->end);
 
     return (uint32_t)(buf->end - buf->wpos);
 }
 
-/* Total capacity of given buf */
+/* Total size of given buf, including header */
 static inline uint32_t
-buf_size(struct buf *buf)
+buf_size(const struct buf *buf)
 {
     ASSERT(buf->begin < buf->end);
 
-    return (uint32_t)(buf->end - (char*)buf);
+    return (uint32_t)(buf->end - (char *)buf);
 }
 
+/* Size of given buf, not including header */
 static inline uint32_t
-buf_capacity(struct buf *buf)
+buf_capacity(const struct buf *buf)
 {
     ASSERT(buf->begin < buf->end);
 
     return (uint32_t)(buf->end - buf->begin);
 }
 
-/* new capacity needed to append count bytes to the buffer */
+/* new capacity needed to write count bytes to the buffer */
 static inline uint32_t
-buf_new_cap(struct buf *buf, uint32_t count)
+buf_new_cap(const struct buf *buf, uint32_t count)
 {
     ASSERT(buf->begin <= buf->wpos);
 
-    return buf->wpos - buf->begin + count;
+    return count <= buf_wsize(buf) ? 0 : count - buf_wsize(buf);
 }
 
 static inline void
diff --git a/include/buffer/cc_dbuf.h b/include/buffer/cc_dbuf.h
index 185de4734..07ad34f96 100644
--- a/include/buffer/cc_dbuf.h
+++ b/include/buffer/cc_dbuf.h
@@ -29,8 +29,8 @@ extern "C" {
 
 
 /*          name                type                default             description */
-#define DBUF_OPTION(ACTION)                                                                         \
-    ACTION( dbuf_max_power,      OPTION_TYPE_UINT,  DBUF_DEFAULT_MAX,   "max number of doubling"   )
+#define DBUF_OPTION(ACTION)                                                                     \
+    ACTION( dbuf_max_power,      OPTION_TYPE_UINT,  DBUF_DEFAULT_MAX,   "max number of doubles")
 
 typedef struct {
     DBUF_OPTION(OPTION_DECLARE)
@@ -43,7 +43,7 @@ typedef struct {
     ACTION( dbuf_double,    METRIC_COUNTER, "# double completed"   )\
     ACTION( dbuf_double_ex, METRIC_COUNTER, "# double failed"      )\
     ACTION( dbuf_shrink,    METRIC_COUNTER, "# shrink completed"   )\
-    ACTION( dbuf_shrink_ex, METRIC_COUNTER, "# srhink failed"      )\
+    ACTION( dbuf_shrink_ex, METRIC_COUNTER, "# shrink failed"      )\
     ACTION( dbuf_fit,       METRIC_COUNTER, "# fit completed"      )\
     ACTION( dbuf_fit_ex,    METRIC_COUNTER, "# fit failed"         )
 
diff --git a/include/cc_array.h b/include/cc_array.h
index b4aa1feb8..0ffd73c94 100644
--- a/include/cc_array.h
+++ b/include/cc_array.h
@@ -43,37 +43,43 @@ typedef int (*array_compare_fn)(const void *, const void *);
 typedef rstatus_i (*array_each_fn)(void *, void *);
 
 struct array {
-    uint32_t nalloc;    /* # allocated element */
     size_t   size;      /* element size */
+    uint32_t nalloc;    /* # allocated element */
     uint32_t nelem;     /* # element */
     uint8_t  *data;     /* elements */
 };
 
 
-static inline uint32_t
-array_nalloc(const struct array *arr)
-{
-    return arr->nalloc;
-}
-
 static inline size_t
 array_size(const struct array *arr)
 {
     return arr->size;
 }
 
+static inline uint32_t
+array_nalloc(const struct array *arr)
+{
+    return arr->nalloc;
+}
+
 static inline uint32_t
 array_nelem(const struct array *arr)
 {
     return arr->nelem;
 }
 
+static inline size_t
+array_nfree(const struct array *arr)
+{
+    return arr->nalloc - arr->nelem;
+}
+
 /* resets all fields in array to zero w/o freeing up any memory */
 static inline void
 array_reset(struct array *arr)
 {
-    arr->nalloc = 0;
     arr->size = 0;
+    arr->nalloc = 0;
     arr->nelem = 0;
     arr->data = NULL;
 }
@@ -82,8 +88,8 @@ array_reset(struct array *arr)
 static inline void
 array_data_assign(struct array *arr, uint32_t nalloc, size_t size, void *data)
 {
-    arr->nalloc = nalloc;
     arr->size = size;
+    arr->nalloc = nalloc;
     arr->nelem = 0;
     arr->data = data;
 }
diff --git a/include/cc_bstring.h b/include/cc_bstring.h
index b82c8b3f5..86c1aadb7 100644
--- a/include/cc_bstring.h
+++ b/include/cc_bstring.h
@@ -38,15 +38,14 @@ struct bstring {
 #define str2bstr(_str)  (struct bstring){ sizeof(_str) - 1, (_str) }
 #define null_bstring    (struct bstring){ 0, NULL }
 
-#define bstring_set_text(_str, _text) do {       \
-    (_str)->len = (uint32_t)(sizeof(_text) - 1); \
-    (_str)->data = (_text);                      \
+#define bstring_set_literal(_str, _literal) do {    \
+    (_str)->len = (uint32_t)(sizeof(_literal) - 1); \
+    (_str)->data = (_literal);                      \
 } while (0);
 
-/* TODO(yao): rename this */
-#define bstring_set_raw(_str, _raw) do {         \
-    (_str)->len = (uint32_t)(cc_strlen(_raw));   \
-    (_str)->data = (char *)(_raw);               \
+#define bstring_set_cstr(_str, _cstr) do {       \
+    (_str)->len = (uint32_t)(cc_strlen(_cstr));  \
+    (_str)->data = (char *)(_cstr);              \
 } while (0);
 
 void bstring_init(struct bstring *str);
@@ -59,7 +58,6 @@ int bstring_compare(const struct bstring *s1, const struct bstring *s2);
 struct bstring *bstring_alloc(uint32_t size);
 void bstring_free(struct bstring **bstring);
 
-/* TODO(yao): is this endian thing really useful? */
 /* efficient implementation of string comparion of short strings */
 #define str2cmp(m, c0, c1)                                                     \
     (m[0] == c0 && m[1] == c1)
@@ -67,70 +65,79 @@ void bstring_free(struct bstring **bstring);
 #define str3cmp(m, c0, c1, c2)                                                 \
     (m[0] == c0 && m[1] == c1 && m[2] == c2)
 
-#ifdef CC_LITTLE_ENDIAN
-
 #define str4cmp(m, c0, c1, c2, c3)                                             \
-    (*(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0))
+    ((m[0] << 24 | m[1] << 16 | m[2] << 8 | m[3]) ==                           \
+        ((c0 << 24) | (c1 << 16) | (c2 << 8) | c3))
 
 #define str5cmp(m, c0, c1, c2, c3, c4)                                         \
     (str4cmp(m, c0, c1, c2, c3) && (m[4] == c4))
 
 #define str6cmp(m, c0, c1, c2, c3, c4, c5)                                     \
-    (str4cmp(m, c0, c1, c2, c3) &&                                             \
-        (((uint32_t *) m)[1] & 0xffff) == ((c5 << 8) | c4))
+    (str5cmp(m, c0, c1, c2, c3, c4) && m[5] == c5)
 
 #define str7cmp(m, c0, c1, c2, c3, c4, c5, c6)                                 \
-    (str6cmp(m, c0, c1, c2, c3, c4, c5) && (m[6] == c6))
+    (str6cmp(m, c0, c1, c2, c3, c4, c5) && m[6] == c6)
 
 #define str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                             \
     (str4cmp(m, c0, c1, c2, c3) &&                                             \
-        (((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)))
+        (m[4] << 24 | m[5] << 16 | m[6] << 8 | m[7]) ==                        \
+        ((c4 << 24) | (c5 << 16) | (c6 << 8) | c7))
 
 #define str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                         \
     (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) && m[8] == c8)
 
 #define str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9)                    \
-    (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) &&                             \
-        (((uint32_t *) m)[2] & 0xffff) == ((c9 << 8) | c8))
+    (str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8) && m[9] == c9)
 
 #define str11cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)               \
-    (str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9) && (m[10] == c10))
+    (str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9) && m[10] == c10)
 
 #define str12cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)          \
     (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) &&                             \
-        (((uint32_t *) m)[2] == ((c11 << 24) | (c10 << 16) | (c9 << 8) | c8)))
-
-#else // BIG ENDIAN
+        (m[8] << 24 | m[9] << 16 | m[10] << 8 | m[11]) ==                      \
+        ((c8 << 24) | (c9 << 16) | (c10 << 8) | c11))
+
+/* below is a more efficient implementation for little-endian only, it takes
+ * about 50% the cycles compared to the generic implementation above in the
+ * extreme cases (e.g. string length being multiples of 4), however, our
+ * profiling showed that string comparison does not contribute meaningfully to
+ * overall processing cost, both events and hashes are far more notable, and
+ * therefore we can choose the generic implementation until profiling results
+ * indicate otherwise.
+ */
 
+/*
 #define str4cmp(m, c0, c1, c2, c3)                                             \
-    (str3cmp(m, c0, c1, c2) && (m3 == c3))
+    (*(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0))
 
 #define str5cmp(m, c0, c1, c2, c3, c4)                                         \
     (str4cmp(m, c0, c1, c2, c3) && (m[4] == c4))
 
 #define str6cmp(m, c0, c1, c2, c3, c4, c5)                                     \
-    (str5cmp(m, c0, c1, c2, c3, c4) && m[5] == c5)
+    (str4cmp(m, c0, c1, c2, c3) &&                                             \
+        (((uint32_t *) m)[1] & 0xffff) == ((c5 << 8) | c4))
 
 #define str7cmp(m, c0, c1, c2, c3, c4, c5, c6)                                 \
-    (str6cmp(m, c0, c1, c2, c3, c4, c5) && m[6] == c6)
+    (str6cmp(m, c0, c1, c2, c3, c4, c5) && (m[6] == c6))
 
 #define str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                             \
-    (str7cmp(m, c0, c1, c2, c3, c4, c5, c6) && m[7] == c7)
+    (str4cmp(m, c0, c1, c2, c3) &&                                             \
+        (((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)))
 
 #define str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                         \
     (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) && m[8] == c8)
 
 #define str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9)                    \
-    (str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8) && m[9] == c9)
+    (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) &&                             \
+        (((uint32_t *) m)[2] & 0xffff) == ((c9 << 8) | c8))
 
 #define str11cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)               \
-    (str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9) && m[10] == c10)
+    (str10cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9) && (m[10] == c10))
 
 #define str12cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)          \
-    (str11cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) && m[11] == c11)
-
-#endif // CC_LITTLE_ENDIAN
-
+    (str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7) &&                             \
+        (((uint32_t *) m)[2] == ((c11 << 24) | (c10 << 16) | (c9 << 8) | c8)))
+*/
 
 /*
  * Wrapper around common routines for manipulating C character strings
@@ -163,6 +170,7 @@ void bstring_free(struct bstring **bstring);
 
 /* bstring to uint conversion */
 rstatus_i bstring_atou64(uint64_t *u64, struct bstring *str);
+rstatus_i bstring_atoi64(int64_t *i64, struct bstring *str);
 
 #ifdef __cplusplus
 }
diff --git a/include/cc_define.h b/include/cc_define.h
index b521b133e..6a207036f 100644
--- a/include/cc_define.h
+++ b/include/cc_define.h
@@ -27,13 +27,6 @@ extern "C" {
 # define CC_HAVE_SIGNAME 1
 #endif
 
-
-#ifdef HAVE_BIG_ENDIAN
-# define CC_BIG_ENDIAN 1
-#else
-# define CC_LITTLE_ENDIAN 1
-#endif
-
 #ifdef HAVE_STATS
 # define CC_STATS 1
 #endif
@@ -54,10 +47,18 @@ extern "C" {
 # define CC_BACKTRACE 1
 #endif
 
+#ifdef HAVE_ACCEPT4
+# define CC_ACCEPT4 1
+#endif
+
 #ifdef HAVE_DEBUG_MM
 #define CC_DEBUG_MM 1
 #endif
 
+#ifdef HAVE_ITT_INSTRUMENTATION
+#define CC_ITT 1
+#endif
+
 #define CC_OK        0
 #define CC_ERROR    -1
 
diff --git a/include/cc_event.h b/include/cc_event.h
index 2f38caa6b..f5a31d281 100644
--- a/include/cc_event.h
+++ b/include/cc_event.h
@@ -26,8 +26,6 @@ extern "C" {
 
 #include <inttypes.h>
 
-#define EVENT_SIZE  1024
-
 #define EVENT_READ  0x0000ff
 #define EVENT_WRITE 0x00ff00
 #define EVENT_ERR   0xff0000
@@ -51,7 +49,7 @@ void event_setup(event_metrics_st *metrics);
 void event_teardown(void);
 
 /* event base */
-struct event_base *event_base_create(int size, event_cb_fn cb);
+struct event_base *event_base_create(int nevent, event_cb_fn cb);
 void event_base_destroy(struct event_base **evb);
 
 /* event control */
diff --git a/include/cc_itt.h b/include/cc_itt.h
new file mode 100644
index 000000000..583c72d93
--- /dev/null
+++ b/include/cc_itt.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cc_define.h>
+
+#ifdef CC_ITT
+#include "ittnotify.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef CC_ITT
+
+#define ITT_DOMAIN_NAME "cc_itt"
+
+#define cc_declare_itt_function(_keyword, _name)                                 \
+    _keyword __itt_heap_function _name
+
+#define cc_create_itt_malloc(_name)                                              \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_create_itt_free(_name)                                                \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_create_itt_realloc(_name)                                             \
+    _name = __itt_heap_function_create(#_name, ITT_DOMAIN_NAME)
+
+#define cc_itt_alloc(_itt_heap_f, _p, _s) do {                                   \
+    __itt_heap_allocate_begin(_itt_heap_f, (size_t)(_s), 0);                     \
+    __itt_heap_allocate_end(_itt_heap_f, (void *)&(_p), (size_t)(_s), 0);        \
+} while (0)
+
+#define cc_itt_zalloc(_itt_heap_f, _p, _s) do {                                  \
+    __itt_heap_allocate_begin(_itt_heap_f, (size_t)(_s), 1);                     \
+    __itt_heap_allocate_end(_itt_heap_f, (void *)&(_p), (size_t)(_s), 1);        \
+} while (0)
+
+#define cc_itt_free(_itt_heap_f, _p) do {                                        \
+    __itt_heap_free_begin(_itt_heap_f, _p);                                      \
+    __itt_heap_free_end(_itt_heap_f, _p);                                        \
+} while (0)
+
+#define cc_itt_realloc(_itt_heap_f, _p, _np, _s) do {                            \
+    __itt_heap_reallocate_begin(_itt_heap_f, _p, (size_t)(_s), 0);               \
+    __itt_heap_reallocate_end(_itt_heap_f, _p, (void *)&(_np), (size_t)(_s), 0); \
+} while (0)
+
+#define cc_itt_heap_internal_access()                                            \
+    __itt_heap_internal_access_begin()
+
+#define cc_itt_heap_internal_access_end()                                        \
+    __itt_heap_internal_access_end()
+
+#else
+#define cc_declare_itt_function(_keyword, _name)
+#define cc_create_itt_malloc(_name)
+#define cc_create_itt_free(_name)
+#define cc_create_itt_realloc(_name)
+#define cc_itt_alloc(_itt_heap_f, _p, _s)
+#define cc_itt_zalloc(_itt_heap_f, _p, _s)
+#define cc_itt_free(_itt_heap_f, _p)
+#define cc_itt_realloc(_itt_heap_f, _p, _np, _s)
+#define cc_itt_heap_internal_access_begin()
+#define cc_itt_heap_internal_access_end()
+#endif /* CC_ITT */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/cc_log.h b/include/cc_log.h
index d61fcff91..f308842d8 100644
--- a/include/cc_log.h
+++ b/include/cc_log.h
@@ -61,6 +61,10 @@ typedef struct {
 void log_setup(log_metrics_st *metrics);
 void log_teardown(void);
 
+/* these two are for testing purposes only */
+log_metrics_st *log_metrics_create(void);
+void log_metrics_destroy(log_metrics_st **p);
+
 /**
  * Create a logger. If filename is NULL, created logger writes to stderr.
  * buf_cap is the size of the buffer used for pauseless logging. specify
diff --git a/include/cc_mm.h b/include/cc_mm.h
index 2d982196e..a9effa23b 100644
--- a/include/cc_mm.h
+++ b/include/cc_mm.h
@@ -66,6 +66,9 @@ extern "C" {
 #define cc_munmap(_p, _s)                                       \
     _cc_munmap(_p, (size_t)(_s), __FILE__, __LINE__)
 
+#define cc_alloc_usable_size(_p)                                \
+    _cc_alloc_usable_size(_p, __FILE__, __LINE__)
+
 void * _cc_alloc(size_t size, const char *name, int line);
 void * _cc_zalloc(size_t size, const char *name, int line);
 void * _cc_calloc(size_t nmemb, size_t size, const char *name, int line);
@@ -74,6 +77,7 @@ void * _cc_realloc_move(void *ptr, size_t size, const char *name, int line);
 void _cc_free(void *ptr, const char *name, int line);
 void * _cc_mmap(size_t size, const char *name, int line);
 int _cc_munmap(void *p, size_t size, const char *name, int line);
+size_t _cc_alloc_usable_size(void *ptr, const char *name, int line);
 
 #ifdef __cplusplus
 }
diff --git a/include/cc_queue.h b/include/cc_queue.h
index c8f8a5ce2..06bf9c31a 100644
--- a/include/cc_queue.h
+++ b/include/cc_queue.h
@@ -127,6 +127,7 @@ extern "C" {
  * _INSERT_TAIL         -       -       +       +       +
  * _REMOVE_HEAD         +       -       +       -       -
  * _REMOVE              +       +       +       +       +
+ * _REINIT              -       -       -       +       -
  *
  */
 
@@ -691,6 +692,23 @@ struct {                                                                \
         (head2)->tqh_last = &(head2)->tqh_first;                        \
 } while (0)
 
+#define TAILQ_REINIT(head, var, field, offset) do {                     \
+    TAILQ_FIRST((head)) = var;                                          \
+    TAILQ_FOREACH(var, head, field) {                                   \
+        if ((TAILQ_NEXT((var), field)) != NULL) {                       \
+            TAILQ_NEXT((var), field) =                                  \
+                (void *)((char *)(TAILQ_NEXT((var), field)) + (offset));\
+        }                                                               \
+        if ((var) == TAILQ_FIRST(head)) {                               \
+            (var)->field.tqe_prev = &TAILQ_FIRST(head);                 \
+        } else {                                                        \
+            (var)->field.tqe_prev =                                     \
+                (void *)((char *)((var)->field.tqe_prev) + (offset));   \
+        }                                                               \
+        (head)->tqh_last = &TAILQ_NEXT((var), field);                   \
+    }                                                                   \
+} while (0)
+
 /*
  * Circular queue declarations.
  */
diff --git a/include/cc_stats_log.h b/include/cc_stats_log.h
new file mode 100644
index 000000000..b33972770
--- /dev/null
+++ b/include/cc_stats_log.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <cc_metric.h>
+#include <cc_option.h>
+
+
+#define STATS_LOG_FILE  NULL    /* default log file */
+#define STATS_LOG_NBUF  0       /* default log buf size */
+
+/*          name            type              default           description */
+#define STATS_LOG_OPTION(ACTION)                                                         \
+    ACTION( stats_log_file, OPTION_TYPE_STR,  NULL,             "file storing stats"   )\
+    ACTION( stats_log_nbuf, OPTION_TYPE_UINT, STATS_LOG_NBUF,   "stats log buf size"   )
+
+typedef struct {
+    STATS_LOG_OPTION(OPTION_DECLARE)
+} stats_log_options_st;
+
+
+/* dump stats as CSV records into a log file, this allows metrics to be captured
+ * locally without setting up an observability infrastructure
+ */
+void stats_log_setup(stats_log_options_st *options);
+void stats_log_teardown(void);
+
+void stats_log(struct metric metrics[], unsigned int nmetric);
+
+void stats_log_flush(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/include/cc_util.h b/include/cc_util.h
index d9c13955b..f8a770059 100644
--- a/include/cc_util.h
+++ b/include/cc_util.h
@@ -86,6 +86,9 @@ extern "C" {
 #define cc_strlen(_s)                                           \
     strlen((char *)(_s))
 
+#define cc_strnlen(_s, _n)                                      \
+    strnlen((char *)(_s), (size_t)(_n))
+
 #define cc_strcmp(_s1, _s2)                                     \
     strcmp((char *)(_s1), (char *)(_s2))
 
diff --git a/include/hash/xxhash.h b/include/hash/xxhash.h
new file mode 100644
index 000000000..a951edb4e
--- /dev/null
+++ b/include/hash/xxhash.h
@@ -0,0 +1,4795 @@
+/*
+ * ccommon - a cache common library.
+ * Copyright (C) 2021 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * the xxhash library is adopted from the xxhash repo, current version 0.80, 
+ * it achieve a higher throughput compared to murmurhash3 with similar hash quality 
+ * 
+ * the most common functions used are 
+ * XXH64_hash_t XXH3_64bits(const void* data, size_t len);
+ * XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
+ * 
+ */
+
+
+
+/*
+ * xxHash - Extremely Fast Hash algorithm
+ * Header File
+ * Copyright (C) 2012-2020 Yann Collet
+ *
+ * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following disclaimer
+ *      in the documentation and/or other materials provided with the
+ *      distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * You can contact the author at:
+ *   - xxHash homepage: https://www.xxhash.com
+ *   - xxHash source repository: https://github.com/Cyan4973/xxHash
+ */
+
+/* TODO: update */
+/* Notice extracted from xxHash homepage:
+
+xxHash is an extremely fast hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+
+Note: SMHasher's CRC32 implementation is not the fastest one.
+Other speed-oriented implementations can be faster,
+especially in combination with PCLMUL instruction:
+https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html?showComment=1552696407071#c3490092340461170735
+
+A 64-bit version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bit applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
+*/
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* ****************************
+ *  INLINE mode
+ ******************************/
+/*!
+ * XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ * Use these build macros to inline xxhash into the target unit.
+ * Inlining improves performance on small inputs, especially when the length is
+ * expressed as a compile-time constant:
+ *
+ *      https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html
+ *
+ * It also keeps xxHash symbols private to the unit, so they are not exported.
+ *
+ * Usage:
+ *     #define XXH_INLINE_ALL
+ *     #include "xxhash.h"
+ *
+ * Do not compile and link xxhash.o as a separate object, as it is not useful.
+ */
+#if (defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)) \
+    && !defined(XXH_INLINE_ALL_31684351384)
+   /* this section should be traversed only once */
+#  define XXH_INLINE_ALL_31684351384
+   /* give access to the advanced API, required to compile implementations */
+#  undef XXH_STATIC_LINKING_ONLY   /* avoid macro redef */
+#  define XXH_STATIC_LINKING_ONLY
+   /* make all functions private */
+#  undef XXH_PUBLIC_API
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+     /* note: this version may generate warnings for unused static functions */
+#    define XXH_PUBLIC_API static
+#  endif
+
+   /*
+    * This part deals with the special case where a unit wants to inline xxHash,
+    * but "xxhash.h" has previously been included without XXH_INLINE_ALL, such
+    * as part of some previously included *.h header file.
+    * Without further action, the new include would just be ignored,
+    * and functions would effectively _not_ be inlined (silent failure).
+    * The following macros solve this situation by prefixing all inlined names,
+    * avoiding naming collision with previous inclusions.
+    */
+#  ifdef XXH_NAMESPACE
+#    error "XXH_INLINE_ALL with XXH_NAMESPACE is not supported"
+     /*
+      * Note: Alternative: #undef all symbols (it's a pretty large list).
+      * Without #error: it compiles, but functions are actually not inlined.
+      */
+#  endif
+#  define XXH_NAMESPACE XXH_INLINE_
+   /*
+    * Some identifiers (enums, type names) are not symbols, but they must
+    * still be renamed to avoid redeclaration.
+    * Alternative solution: do not redeclare them.
+    * However, this requires some #ifdefs, and is a more dispersed action.
+    * Meanwhile, renaming can be achieved in a single block
+    */
+#  define XXH_IPREF(Id)   XXH_INLINE_ ## Id
+#  define XXH_OK XXH_IPREF(XXH_OK)
+#  define XXH_ERROR XXH_IPREF(XXH_ERROR)
+#  define XXH_errorcode XXH_IPREF(XXH_errorcode)
+#  define XXH32_canonical_t  XXH_IPREF(XXH32_canonical_t)
+#  define XXH64_canonical_t  XXH_IPREF(XXH64_canonical_t)
+#  define XXH128_canonical_t XXH_IPREF(XXH128_canonical_t)
+#  define XXH32_state_s XXH_IPREF(XXH32_state_s)
+#  define XXH32_state_t XXH_IPREF(XXH32_state_t)
+#  define XXH64_state_s XXH_IPREF(XXH64_state_s)
+#  define XXH64_state_t XXH_IPREF(XXH64_state_t)
+#  define XXH3_state_s  XXH_IPREF(XXH3_state_s)
+#  define XXH3_state_t  XXH_IPREF(XXH3_state_t)
+#  define XXH128_hash_t XXH_IPREF(XXH128_hash_t)
+   /* Ensure the header is parsed again, even if it was previously included */
+#  undef XXHASH_H_5627135585666179
+#  undef XXHASH_H_STATIC_13879238742
+#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
+
+
+
+/* ****************************************************************
+ *  Stable API
+ *****************************************************************/
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
+
+/* specific declaration modes for Windows */
+#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)
+#  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))
+#    ifdef XXH_EXPORT
+#      define XXH_PUBLIC_API __declspec(dllexport)
+#    elif XXH_IMPORT
+#      define XXH_PUBLIC_API __declspec(dllimport)
+#    endif
+#  else
+#    define XXH_PUBLIC_API   /* do nothing */
+#  endif
+#endif
+
+/*!
+ * XXH_NAMESPACE, aka Namespace Emulation:
+ *
+ * If you want to include _and expose_ xxHash functions from within your own
+ * library, but also want to avoid symbol collisions with other libraries which
+ * may also include xxHash, you can use XXH_NAMESPACE to automatically prefix
+ * any public symbol from xxhash library with the value of XXH_NAMESPACE
+ * (therefore, avoid empty or numeric values).
+ *
+ * Note that no change is required within the calling program as long as it
+ * includes `xxhash.h`: Regular symbol names will be automatically translated
+ * by this header.
+ */
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+/* XXH32 */
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+/* XXH64 */
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+/* XXH3_64bits */
+#  define XXH3_64bits XXH_NAME2(XXH_NAMESPACE, XXH3_64bits)
+#  define XXH3_64bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecret)
+#  define XXH3_64bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSeed)
+#  define XXH3_createState XXH_NAME2(XXH_NAMESPACE, XXH3_createState)
+#  define XXH3_freeState XXH_NAME2(XXH_NAMESPACE, XXH3_freeState)
+#  define XXH3_copyState XXH_NAME2(XXH_NAMESPACE, XXH3_copyState)
+#  define XXH3_64bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset)
+#  define XXH3_64bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSeed)
+#  define XXH3_64bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecret)
+#  define XXH3_64bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_update)
+#  define XXH3_64bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_digest)
+#  define XXH3_generateSecret XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret)
+/* XXH3_128bits */
+#  define XXH128 XXH_NAME2(XXH_NAMESPACE, XXH128)
+#  define XXH3_128bits XXH_NAME2(XXH_NAMESPACE, XXH3_128bits)
+#  define XXH3_128bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSeed)
+#  define XXH3_128bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecret)
+#  define XXH3_128bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset)
+#  define XXH3_128bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSeed)
+#  define XXH3_128bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecret)
+#  define XXH3_128bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_update)
+#  define XXH3_128bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_digest)
+#  define XXH128_isEqual XXH_NAME2(XXH_NAMESPACE, XXH128_isEqual)
+#  define XXH128_cmp     XXH_NAME2(XXH_NAMESPACE, XXH128_cmp)
+#  define XXH128_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH128_canonicalFromHash)
+#  define XXH128_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH128_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    8
+#define XXH_VERSION_RELEASE  0
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/* ****************************
+*  Definitions
+******************************/
+#include <stddef.h>   /* size_t */
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+/*-**********************************************************************
+*  32-bit hash
+************************************************************************/
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint32_t XXH32_hash_t;
+#else
+#   include <limits.h>
+#   if UINT_MAX == 0xFFFFFFFFUL
+      typedef unsigned int XXH32_hash_t;
+#   else
+#     if ULONG_MAX == 0xFFFFFFFFUL
+        typedef unsigned long XXH32_hash_t;
+#     else
+#       error "unsupported platform: need a 32-bit type"
+#     endif
+#   endif
+#endif
+
+/*!
+ * XXH32():
+ *  Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
+ *  The memory between input & input+length must be valid (allocated and read-accessible).
+ *  "seed" can be used to alter the result predictably.
+ *  Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark): 5.4 GB/s
+ *
+ * Note: XXH3 provides competitive speed for both 32-bit and 64-bit systems,
+ * and offers true 64/128 bit hash results. It provides a superior level of
+ * dispersion, and greatly reduces the risks of collisions.
+ */
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);
+
+/*******   Streaming   *******/
+
+/*
+ * Streaming functions generate the xxHash value from an incrememtal input.
+ * This method is slower than single-call functions, due to state management.
+ * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
+ *
+ * An XXH state must first be allocated using `XXH*_createState()`.
+ *
+ * Start a new hash by initializing the state with a seed using `XXH*_reset()`.
+ *
+ * Then, feed the hash state by calling `XXH*_update()` as many times as necessary.
+ *
+ * The function returns an error code, with 0 meaning OK, and any other value
+ * meaning there is an error.
+ *
+ * Finally, a hash value can be produced anytime, by using `XXH*_digest()`.
+ * This function returns the nn-bits hash as an int or long long.
+ *
+ * It's still possible to continue inserting input into the hash state after a
+ * digest, and generate new hash values later on by invoking `XXH*_digest()`.
+ *
+ * When done, release the state using `XXH*_freeState()`.
+ */
+
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, XXH32_hash_t seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+
+/*******   Canonical representation   *******/
+
+/*
+ * The default return values from XXH functions are unsigned 32 and 64 bit
+ * integers.
+ * This the simplest and fastest format for further post-processing.
+ *
+ * However, this leaves open the question of what is the order on the byte level,
+ * since little and big endian conventions will store the same number differently.
+ *
+ * The canonical representation settles this issue by mandating big-endian
+ * convention, the same convention as human-readable numbers (large digits first).
+ *
+ * When writing hash values to storage, sending them over a network, or printing
+ * them, it's highly recommended to use the canonical representation to ensure
+ * portability across a wider range of systems, present and future.
+ *
+ * The following functions allow transformation of hash values to and from
+ * canonical format.
+ */
+
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+
+
+#ifndef XXH_NO_LONG_LONG
+/*-**********************************************************************
+*  64-bit hash
+************************************************************************/
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint64_t XXH64_hash_t;
+#else
+    /* the following type must have a width of 64-bit */
+    typedef unsigned long long XXH64_hash_t;
+#endif
+
+/*!
+ * XXH64():
+ * Returns the 64-bit hash of sequence of length @length stored at memory
+ * address @input.
+ * @seed can be used to alter the result predictably.
+ *
+ * This function usually runs faster on 64-bit systems, but slower on 32-bit
+ * systems (see benchmark).
+ *
+ * Note: XXH3 provides competitive speed for both 32-bit and 64-bit systems,
+ * and offers true 64/128 bit hash results. It provides a superior level of
+ * dispersion, and greatly reduces the risks of collisions.
+ */
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, XXH64_hash_t seed);
+
+/*******   Streaming   *******/
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*******   Canonical representation   *******/
+typedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+
+
+/*-**********************************************************************
+*  XXH3 64-bit variant
+************************************************************************/
+
+/* ************************************************************************
+ * XXH3 is a new hash algorithm featuring:
+ *  - Improved speed for both small and large inputs
+ *  - True 64-bit and 128-bit outputs
+ *  - SIMD acceleration
+ *  - Improved 32-bit viability
+ *
+ * Speed analysis methodology is explained here:
+ *
+ *    https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html
+ *
+ * In general, expect XXH3 to run about ~2x faster on large inputs and >3x
+ * faster on small ones compared to XXH64, though exact differences depend on
+ * the platform.
+ *
+ * The algorithm is portable: Like XXH32 and XXH64, it generates the same hash
+ * on all platforms.
+ *
+ * It benefits greatly from SIMD and 64-bit arithmetic, but does not require it.
+ *
+ * Almost all 32-bit and 64-bit targets that can run XXH32 smoothly can run
+ * XXH3 at competitive speeds, even if XXH64 runs slowly. Further details are
+ * explained in the implementation.
+ *
+ * Optimized implementations are provided for AVX512, AVX2, SSE2, NEON, POWER8,
+ * ZVector and scalar targets. This can be controlled with the XXH_VECTOR macro.
+ *
+ * XXH3 offers 2 variants, _64bits and _128bits.
+ * When only 64 bits are needed, prefer calling the _64bits variant, as it
+ * reduces the amount of mixing, resulting in faster speed on small inputs.
+ *
+ * It's also generally simpler to manipulate a scalar return type than a struct.
+ *
+ * The 128-bit version adds additional strength, but it is slightly slower.
+ *
+ * The XXH3 algorithm is still in development.
+ * The results it produces may still change in future versions.
+ *
+ * Results produced by v0.7.x are not comparable with results from v0.7.y.
+ * However, the API is completely stable, and it can safely be used for
+ * ephemeral data (local sessions).
+ *
+ * Avoid storing values in long-term storage until the algorithm is finalized.
+ * XXH3's return values will be officially finalized upon reaching v0.8.0.
+ *
+ * After which, return values of XXH3 and XXH128 will no longer change in
+ * future versions.
+ *
+ * The API supports one-shot hashing, streaming mode, and custom secrets.
+ */
+
+/* XXH3_64bits():
+ * default 64-bit variant, using default secret and default seed of 0.
+ * It's the fastest variant. */
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* data, size_t len);
+
+/*
+ * XXH3_64bits_withSeed():
+ * This variant generates a custom secret on the fly
+ * based on default secret altered using the `seed` value.
+ * While this operation is decently fast, note that it's not completely free.
+ * Note: seed==0 produces the same results as XXH3_64bits().
+ */
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
+
+/*
+ * XXH3_64bits_withSecret():
+ * It's possible to provide any blob of bytes as a "secret" to generate the hash.
+ * This makes it more difficult for an external actor to prepare an intentional collision.
+ * The main condition is that secretSize *must* be large enough (>= XXH3_SECRET_SIZE_MIN).
+ * However, the quality of produced hash values depends on secret's entropy.
+ * Technically, the secret must look like a bunch of random bytes.
+ * Avoid "trivial" or structured data such as repeated sequences or a text document.
+ * Whenever unsure about the "randomness" of the blob of bytes,
+ * consider relabelling it as a "custom seed" instead,
+ * and employ "XXH3_generateSecret()" (see below)
+ * to generate a high entropy secret derived from the custom seed.
+ */
+#define XXH3_SECRET_SIZE_MIN 136
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
+
+
+/*******   Streaming   *******/
+/*
+ * Streaming requires state maintenance.
+ * This operation costs memory and CPU.
+ * As a consequence, streaming is slower than one-shot hashing.
+ * For better performance, prefer one-shot functions whenever applicable.
+ */
+typedef struct XXH3_state_s XXH3_state_t;
+XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void);
+XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr);
+XXH_PUBLIC_API void XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state);
+
+/*
+ * XXH3_64bits_reset():
+ * Initialize with default parameters.
+ * digest will be equivalent to `XXH3_64bits()`.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH3_state_t* statePtr);
+/*
+ * XXH3_64bits_reset_withSeed():
+ * Generate a custom secret from `seed`, and store it into `statePtr`.
+ * digest will be equivalent to `XXH3_64bits_withSeed()`.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed);
+/*
+ * XXH3_64bits_reset_withSecret():
+ * `secret` is referenced, it _must outlive_ the hash streaming session.
+ * Similar to one-shot API, `secretSize` must be >= `XXH3_SECRET_SIZE_MIN`,
+ * and the quality of produced hash values depends on secret's entropy
+ * (secret's content should look like a bunch of random bytes).
+ * When in doubt about the randomness of a candidate `secret`,
+ * consider employing `XXH3_generateSecret()` instead (see below).
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize);
+
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH3_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH3_64bits_digest (const XXH3_state_t* statePtr);
+
+/* note : canonical representation of XXH3 is the same as XXH64
+ * since they both produce XXH64_hash_t values */
+
+
+/*-**********************************************************************
+*  XXH3 128-bit variant
+************************************************************************/
+
+typedef struct {
+ XXH64_hash_t low64;
+ XXH64_hash_t high64;
+} XXH128_hash_t;
+
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* data, size_t len);
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
+
+/*******   Streaming   *******/
+/*
+ * Streaming requires state maintenance.
+ * This operation costs memory and CPU.
+ * As a consequence, streaming is slower than one-shot hashing.
+ * For better performance, prefer one-shot functions whenever applicable.
+ *
+ * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits().
+ * Use already declared XXH3_createState() and XXH3_freeState().
+ *
+ * All reset and streaming functions have same meaning as their 64-bit counterpart.
+ */
+
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH3_state_t* statePtr);
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize);
+
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH3_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* statePtr);
+
+/* Following helper functions make it possible to compare XXH128_hast_t values.
+ * Since XXH128_hash_t is a structure, this capability is not offered by the language.
+ * Note: For better performance, these functions can be inlined using XXH_INLINE_ALL */
+
+/*!
+ * XXH128_isEqual():
+ * Return: 1 if `h1` and `h2` are equal, 0 if they are not.
+ */
+XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);
+
+/*!
+ * XXH128_cmp():
+ *
+ * This comparator is compatible with stdlib's `qsort()`/`bsearch()`.
+ *
+ * return: >0 if *h128_1  > *h128_2
+ *         =0 if *h128_1 == *h128_2
+ *         <0 if *h128_1  < *h128_2
+ */
+XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2);
+
+
+/*******   Canonical representation   *******/
+typedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_canonical_t;
+XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash);
+XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical(const XXH128_canonical_t* src);
+
+
+#endif  /* XXH_NO_LONG_LONG */
+
+#endif /* XXHASH_H_5627135585666179 */
+
+
+
+#if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742)
+#define XXHASH_H_STATIC_13879238742
+/* ****************************************************************************
+ * This section contains declarations which are not guaranteed to remain stable.
+ * They may change in future versions, becoming incompatible with a different
+ * version of the library.
+ * These declarations should only be used with static linking.
+ * Never use them in association with dynamic linking!
+ ***************************************************************************** */
+
+/*
+ * These definitions are only present to allow static allocation
+ * of XXH states, on stack or in a struct, for example.
+ * Never **ever** access their members directly.
+ */
+
+struct XXH32_state_s {
+   XXH32_hash_t total_len_32;
+   XXH32_hash_t large_len;
+   XXH32_hash_t v1;
+   XXH32_hash_t v2;
+   XXH32_hash_t v3;
+   XXH32_hash_t v4;
+   XXH32_hash_t mem32[4];
+   XXH32_hash_t memsize;
+   XXH32_hash_t reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+
+#ifndef XXH_NO_LONG_LONG  /* defined when there is no 64-bit support */
+
+struct XXH64_state_s {
+   XXH64_hash_t total_len;
+   XXH64_hash_t v1;
+   XXH64_hash_t v2;
+   XXH64_hash_t v3;
+   XXH64_hash_t v4;
+   XXH64_hash_t mem64[4];
+   XXH32_hash_t memsize;
+   XXH32_hash_t reserved32;  /* required for padding anyway */
+   XXH64_hash_t reserved64;  /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+
+#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)   /* C11+ */
+#  include <stdalign.h>
+#  define XXH_ALIGN(n)      alignas(n)
+#elif defined(__GNUC__)
+#  define XXH_ALIGN(n)      __attribute__ ((aligned(n)))
+#elif defined(_MSC_VER)
+#  define XXH_ALIGN(n)      __declspec(align(n))
+#else
+#  define XXH_ALIGN(n)   /* disabled */
+#endif
+
+/* Old GCC versions only accept the attribute after the type in structures. */
+#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L))   /* C11+ */ \
+    && defined(__GNUC__)
+#   define XXH_ALIGN_MEMBER(align, type) type XXH_ALIGN(align)
+#else
+#   define XXH_ALIGN_MEMBER(align, type) XXH_ALIGN(align) type
+#endif
+
+#define XXH3_INTERNALBUFFER_SIZE 256
+#define XXH3_SECRET_DEFAULT_SIZE 192
+struct XXH3_state_s {
+   XXH_ALIGN_MEMBER(64, XXH64_hash_t acc[8]);
+   /* used to store a custom secret generated from a seed */
+   XXH_ALIGN_MEMBER(64, unsigned char customSecret[XXH3_SECRET_DEFAULT_SIZE]);
+   XXH_ALIGN_MEMBER(64, unsigned char buffer[XXH3_INTERNALBUFFER_SIZE]);
+   XXH32_hash_t bufferedSize;
+   XXH32_hash_t reserved32;
+   size_t nbStripesSoFar;
+   XXH64_hash_t totalLen;
+   size_t nbStripesPerBlock;
+   size_t secretLimit;
+   XXH64_hash_t seed;
+   XXH64_hash_t reserved64;
+   const unsigned char* extSecret;  /* reference to external secret;
+                                     * if == NULL, use .customSecret instead */
+   /* note: there may be some padding at the end due to alignment on 64 bytes */
+}; /* typedef'd to XXH3_state_t */
+
+#undef XXH_ALIGN_MEMBER
+
+/* When the XXH3_state_t structure is merely emplaced on stack,
+ * it should be initialized with XXH3_INITSTATE() or a memset()
+ * in case its first reset uses XXH3_NNbits_reset_withSeed().
+ * This init can be omitted if the first reset uses default or _withSecret mode.
+ * This operation isn't necessary when the state is created with XXH3_createState().
+ * Note that this doesn't prepare the state for a streaming operation,
+ * it's still necessary to use XXH3_NNbits_reset*() afterwards.
+ */
+#define XXH3_INITSTATE(XXH3_state_ptr)   { (XXH3_state_ptr)->seed = 0; }
+
+
+/* ===   Experimental API   === */
+/* Symbols defined below must be considered tied to a specific library version. */
+
+/*
+ * XXH3_generateSecret():
+ *
+ * Derive a high-entropy secret from any user-defined content, named customSeed.
+ * The generated secret can be used in combination with `*_withSecret()` functions.
+ * The `_withSecret()` variants are useful to provide a higher level of protection than 64-bit seed,
+ * as it becomes much more difficult for an external actor to guess how to impact the calculation logic.
+ *
+ * The function accepts as input a custom seed of any length and any content,
+ * and derives from it a high-entropy secret of length XXH3_SECRET_DEFAULT_SIZE
+ * into an already allocated buffer secretBuffer.
+ * The generated secret is _always_ XXH_SECRET_DEFAULT_SIZE bytes long.
+ *
+ * The generated secret can then be used with any `*_withSecret()` variant.
+ * Functions `XXH3_128bits_withSecret()`, `XXH3_64bits_withSecret()`,
+ * `XXH3_128bits_reset_withSecret()` and `XXH3_64bits_reset_withSecret()`
+ * are part of this list. They all accept a `secret` parameter
+ * which must be very long for implementation reasons (>= XXH3_SECRET_SIZE_MIN)
+ * _and_ feature very high entropy (consist of random-looking bytes).
+ * These conditions can be a high bar to meet, so
+ * this function can be used to generate a secret of proper quality.
+ *
+ * customSeed can be anything. It can have any size, even small ones,
+ * and its content can be anything, even stupidly "low entropy" source such as a bunch of zeroes.
+ * The resulting `secret` will nonetheless provide all expected qualities.
+ *
+ * Supplying NULL as the customSeed copies the default secret into `secretBuffer`.
+ * When customSeedSize > 0, supplying NULL as customSeed is undefined behavior.
+ */
+XXH_PUBLIC_API void XXH3_generateSecret(void* secretBuffer, const void* customSeed, size_t customSeedSize);
+
+
+/* simple short-cut to pre-selected XXH3_128bits variant */
+XXH_PUBLIC_API XXH128_hash_t XXH128(const void* data, size_t len, XXH64_hash_t seed);
+
+
+#endif  /* XXH_NO_LONG_LONG */
+
+
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  define XXH_IMPLEMENTATION
+#endif
+
+#endif  /* defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742) */
+
+
+/* ======================================================================== */
+/* ======================================================================== */
+/* ======================================================================== */
+
+
+/*-**********************************************************************
+ * xxHash implementation
+ *-**********************************************************************
+ * xxHash's implementation used to be hosted inside xxhash.c.
+ *
+ * However, inlining requires implementation to be visible to the compiler,
+ * hence be included alongside the header.
+ * Previously, implementation was hosted inside xxhash.c,
+ * which was then #included when inlining was activated.
+ * This construction created issues with a few build and install systems,
+ * as it required xxhash.c to be stored in /include directory.
+ *
+ * xxHash implementation is now directly integrated within xxhash.h.
+ * As a consequence, xxhash.c is no longer needed in /include.
+ *
+ * xxhash.c is still available and is still useful.
+ * In a "normal" setup, when xxhash is not inlined,
+ * xxhash.h only exposes the prototypes and public symbols,
+ * while xxhash.c can be built into an object file xxhash.o
+ * which can then be linked into the final binary.
+ ************************************************************************/
+
+#if ( defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API) \
+   || defined(XXH_IMPLEMENTATION) ) && !defined(XXH_IMPLEM_13a8737387)
+#  define XXH_IMPLEM_13a8737387
+
+/* *************************************
+*  Tuning parameters
+***************************************/
+/*!
+ * XXH_FORCE_MEMORY_ACCESS:
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is
+ * safe and portable.
+ *
+ * Unfortunately, on some target/compiler combinations, the generated assembly
+ * is sub-optimal.
+ *
+ * The below switch allow selection of a different access method
+ * in the search for improved performance.
+ * Method 0 (default):
+ *     Use `memcpy()`. Safe and portable. Default.
+ * Method 1:
+ *     `__attribute__((packed))` statement. It depends on compiler extensions
+ *     and is therefore not portable.
+ *     This method is safe if your compiler supports it, and *generally* as
+ *     fast or faster than `memcpy`.
+ * Method 2:
+ *     Direct access via cast. This method doesn't depend on the compiler but
+ *     violates the C standard.
+ *     It can generate buggy code on targets which do not support unaligned
+ *     memory accesses.
+ *     But in some circumstances, it's the only known way to get the most
+ *     performance (example: GCC + ARMv6)
+ * Method 3:
+ *     Byteshift. This can generate the best code on old compilers which don't
+ *     inline small `memcpy()` calls, and it might also be faster on big-endian
+ *     systems which lack a native byteswap instruction.
+ * See https://stackoverflow.com/a/32095106/646947 for details.
+ * Prefer these methods in priority order (0 > 1 > 2 > 3)
+ */
+#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if !defined(__clang__) && defined(__GNUC__) && defined(__ARM_FEATURE_UNALIGNED) && defined(__ARM_ARCH) && (__ARM_ARCH == 6)
+#    define XXH_FORCE_MEMORY_ACCESS 2
+#  elif !defined(__clang__) && ((defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
+  (defined(__GNUC__) && (defined(__ARM_ARCH) && __ARM_ARCH >= 7)))
+#    define XXH_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+/*!
+ * XXH_ACCEPT_NULL_INPUT_POINTER:
+ * If the input pointer is NULL, xxHash's default behavior is to dereference it,
+ * triggering a segfault.
+ * When this macro is enabled, xxHash actively checks the input for a null pointer.
+ * If it is, the result for null input pointers is the same as a zero-length input.
+ */
+#ifndef XXH_ACCEPT_NULL_INPUT_POINTER   /* can be defined externally */
+#  define XXH_ACCEPT_NULL_INPUT_POINTER 0
+#endif
+
+/*!
+ * XXH_FORCE_ALIGN_CHECK:
+ * This is an important performance trick
+ * for architectures without decent unaligned memory access performance.
+ * It checks for input alignment, and when conditions are met,
+ * uses a "fast path" employing direct 32-bit/64-bit read,
+ * resulting in _dramatically faster_ read speed.
+ *
+ * The check costs one initial branch per hash, which is generally negligible, but not zero.
+ * Moreover, it's not useful to generate binary for an additional code path
+ * if memory access uses same instruction for both aligned and unaligned adresses.
+ *
+ * In these cases, the alignment check can be removed by setting this macro to 0.
+ * Then the code will always use unaligned memory access.
+ * Align check is automatically disabled on x86, x64 & arm64,
+ * which are platforms known to offer good unaligned memory accesses performance.
+ *
+ * This option does not affect XXH3 (only XXH32 and XXH64).
+ */
+#ifndef XXH_FORCE_ALIGN_CHECK  /* can be defined externally */
+#  if defined(__i386)  || defined(__x86_64__) || defined(__aarch64__) \
+   || defined(_M_IX86) || defined(_M_X64)     || defined(_M_ARM64) /* visual */
+#    define XXH_FORCE_ALIGN_CHECK 0
+#  else
+#    define XXH_FORCE_ALIGN_CHECK 1
+#  endif
+#endif
+
+/*!
+ * XXH_NO_INLINE_HINTS:
+ *
+ * By default, xxHash tries to force the compiler to inline almost all internal
+ * functions.
+ *
+ * This can usually improve performance due to reduced jumping and improved
+ * constant folding, but significantly increases the size of the binary which
+ * might not be favorable.
+ *
+ * Additionally, sometimes the forced inlining can be detrimental to performance,
+ * depending on the architecture.
+ *
+ * XXH_NO_INLINE_HINTS marks all internal functions as static, giving the
+ * compiler full control on whether to inline or not.
+ *
+ * When not optimizing (-O0), optimizing for size (-Os, -Oz), or using
+ * -fno-inline with GCC or Clang, this will automatically be defined.
+ */
+#ifndef XXH_NO_INLINE_HINTS
+#  if defined(__OPTIMIZE_SIZE__) /* -Os, -Oz */ \
+   || defined(__NO_INLINE__)     /* -O0, -fno-inline */
+#    define XXH_NO_INLINE_HINTS 1
+#  else
+#    define XXH_NO_INLINE_HINTS 0
+#  endif
+#endif
+
+/*!
+ * XXH_REROLL:
+ * Whether to reroll XXH32_finalize, and XXH64_finalize,
+ * instead of using an unrolled jump table/if statement loop.
+ *
+ * This is automatically defined on -Os/-Oz on GCC and Clang.
+ */
+#ifndef XXH_REROLL
+#  if defined(__OPTIMIZE_SIZE__)
+#    define XXH_REROLL 1
+#  else
+#    define XXH_REROLL 0
+#  endif
+#endif
+
+
+/* *************************************
+*  Includes & Memory related functions
+***************************************/
+/*!
+ * Modify the local functions below should you wish to use
+ * different memory routines for malloc() and free()
+ */
+#include <stdlib.h>
+
+static void* XXH_malloc(size_t s) { return malloc(s); }
+static void XXH_free(void* p) { free(p); }
+
+/*! and for memcpy() */
+#include <string.h>
+static void* XXH_memcpy(void* dest, const void* src, size_t size)
+{
+    return memcpy(dest,src,size);
+}
+
+#include <limits.h>   /* ULLONG_MAX */
+
+
+/* *************************************
+*  Compiler Specific Options
+***************************************/
+#ifdef _MSC_VER /* Visual Studio warning fix */
+#  pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
+#endif
+
+#if XXH_NO_INLINE_HINTS  /* disable inlining hints */
+#  if defined(__GNUC__)
+#    define XXH_FORCE_INLINE static __attribute__((unused))
+#  else
+#    define XXH_FORCE_INLINE static
+#  endif
+#  define XXH_NO_INLINE static
+/* enable inlining hints */
+#elif defined(_MSC_VER)  /* Visual Studio */
+#  define XXH_FORCE_INLINE static __forceinline
+#  define XXH_NO_INLINE static __declspec(noinline)
+#elif defined(__GNUC__)
+#  define XXH_FORCE_INLINE static __inline__ __attribute__((always_inline, unused))
+#  define XXH_NO_INLINE static __attribute__((noinline))
+#elif defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))   /* C99 */
+#  define XXH_FORCE_INLINE static inline
+#  define XXH_NO_INLINE static
+#else
+#  define XXH_FORCE_INLINE static
+#  define XXH_NO_INLINE static
+#endif
+
+
+
+/* *************************************
+*  Debug
+***************************************/
+/*
+ * XXH_DEBUGLEVEL is expected to be defined externally, typically via the
+ * compiler's command line options. The value must be a number.
+ */
+#ifndef XXH_DEBUGLEVEL
+#  ifdef DEBUGLEVEL /* backwards compat */
+#    define XXH_DEBUGLEVEL DEBUGLEVEL
+#  else
+#    define XXH_DEBUGLEVEL 0
+#  endif
+#endif
+
+#if (XXH_DEBUGLEVEL>=1)
+#  include <assert.h>   /* note: can still be disabled with NDEBUG */
+#  define XXH_ASSERT(c)   assert(c)
+#else
+#  define XXH_ASSERT(c)   ((void)0)
+#endif
+
+/* note: use after variable declarations */
+#define XXH_STATIC_ASSERT(c)  do { enum { XXH_sa = 1/(int)(!!(c)) }; } while (0)
+
+
+/* *************************************
+*  Basic Types
+***************************************/
+#if !defined (__VMS) \
+ && (defined (__cplusplus) \
+ || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+# include <stdint.h>
+  typedef uint8_t xxh_u8;
+#else
+  typedef unsigned char xxh_u8;
+#endif
+typedef XXH32_hash_t xxh_u32;
+
+#ifdef XXH_OLD_NAMES
+#  define BYTE xxh_u8
+#  define U8   xxh_u8
+#  define U32  xxh_u32
+#endif
+
+/* ***   Memory access   *** */
+
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))
+/*
+ * Manual byteshift. Best for old compilers which don't inline memcpy.
+ * We actually directly use XXH_readLE32 and XXH_readBE32.
+ */
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
+
+/*
+ * Force direct memory access. Only works on CPU which support unaligned memory
+ * access in hardware.
+ */
+static xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*) memPtr; }
+
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
+
+/*
+ * __pack instructions are safer but compiler specific, hence potentially
+ * problematic for some compilers.
+ *
+ * Currently only defined for GCC and ICC.
+ */
+#ifdef XXH_OLD_NAMES
+typedef union { xxh_u32 u32; } __attribute__((packed)) unalign;
+#endif
+static xxh_u32 XXH_read32(const void* ptr)
+{
+    typedef union { xxh_u32 u32; } __attribute__((packed)) xxh_unalign;
+    return ((const xxh_unalign*)ptr)->u32;
+}
+
+#else
+
+/*
+ * Portable and safe solution. Generally efficient.
+ * see: https://stackoverflow.com/a/32095106/646947
+ */
+static xxh_u32 XXH_read32(const void* memPtr)
+{
+    xxh_u32 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
+
+
+/* ***   Endianess   *** */
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
+
+/*!
+ * XXH_CPU_LITTLE_ENDIAN:
+ * Defined to 1 if the target is little endian, or 0 if it is big endian.
+ * It can be defined externally, for example on the compiler command line.
+ *
+ * If it is not defined, a runtime check (which is usually constant folded)
+ * is used instead.
+ */
+#ifndef XXH_CPU_LITTLE_ENDIAN
+/*
+ * Try to detect endianness automatically, to avoid the nonstandard behavior
+ * in `XXH_isLittleEndian()`
+ */
+#  if defined(_WIN32) /* Windows is always little endian */ \
+     || defined(__LITTLE_ENDIAN__) \
+     || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#    define XXH_CPU_LITTLE_ENDIAN 1
+#  elif defined(__BIG_ENDIAN__) \
+     || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#    define XXH_CPU_LITTLE_ENDIAN 0
+#  else
+/*
+ * runtime test, presumed to simplify to a constant by compiler
+ */
+static int XXH_isLittleEndian(void)
+{
+    /*
+     * Portable and well-defined behavior.
+     * Don't use static: it is detrimental to performance.
+     */
+    const union { xxh_u32 u; xxh_u8 c[4]; } one = { 1 };
+    return one.c[0];
+}
+#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
+#  endif
+#endif
+
+
+
+
+/* ****************************************
+*  Compiler-specific Functions and Macros
+******************************************/
+#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+#ifdef __has_builtin
+#  define XXH_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define XXH_HAS_BUILTIN(x) 0
+#endif
+
+#if !defined(NO_CLANG_BUILTIN) && XXH_HAS_BUILTIN(__builtin_rotateleft32) \
+                               && XXH_HAS_BUILTIN(__builtin_rotateleft64)
+#  define XXH_rotl32 __builtin_rotateleft32
+#  define XXH_rotl64 __builtin_rotateleft64
+/* Note: although _rotl exists for minGW (GCC under windows), performance seems poor */
+#elif defined(_MSC_VER)
+#  define XXH_rotl32(x,r) _rotl(x,r)
+#  define XXH_rotl64(x,r) _rotl64(x,r)
+#else
+#  define XXH_rotl32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
+#  define XXH_rotl64(x,r) (((x) << (r)) | ((x) >> (64 - (r))))
+#endif
+
+#if defined(_MSC_VER)     /* Visual Studio */
+#  define XXH_swap32 _byteswap_ulong
+#elif XXH_GCC_VERSION >= 403
+#  define XXH_swap32 __builtin_bswap32
+#else
+static xxh_u32 XXH_swap32 (xxh_u32 x)
+{
+    return  ((x << 24) & 0xff000000 ) |
+            ((x <<  8) & 0x00ff0000 ) |
+            ((x >>  8) & 0x0000ff00 ) |
+            ((x >> 24) & 0x000000ff );
+}
+#endif
+
+
+/* ***************************
+*  Memory reads
+*****************************/
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
+
+/*
+ * XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load.
+ *
+ * This is ideal for older compilers which don't inline memcpy.
+ */
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))
+
+XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr)
+{
+    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;
+    return bytePtr[0]
+         | ((xxh_u32)bytePtr[1] << 8)
+         | ((xxh_u32)bytePtr[2] << 16)
+         | ((xxh_u32)bytePtr[3] << 24);
+}
+
+XXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr)
+{
+    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;
+    return bytePtr[3]
+         | ((xxh_u32)bytePtr[2] << 8)
+         | ((xxh_u32)bytePtr[1] << 16)
+         | ((xxh_u32)bytePtr[0] << 24);
+}
+
+#else
+XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
+}
+
+static xxh_u32 XXH_readBE32(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
+}
+#endif
+
+XXH_FORCE_INLINE xxh_u32
+XXH_readLE32_align(const void* ptr, XXH_alignment align)
+{
+    if (align==XXH_unaligned) {
+        return XXH_readLE32(ptr);
+    } else {
+        return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u32*)ptr : XXH_swap32(*(const xxh_u32*)ptr);
+    }
+}
+
+
+/* *************************************
+*  Misc
+***************************************/
+XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
+
+
+/* *******************************************************************
+*  32-bit hash functions
+*********************************************************************/
+static const xxh_u32 XXH_PRIME32_1 = 0x9E3779B1U;   /* 0b10011110001101110111100110110001 */
+static const xxh_u32 XXH_PRIME32_2 = 0x85EBCA77U;   /* 0b10000101111010111100101001110111 */
+static const xxh_u32 XXH_PRIME32_3 = 0xC2B2AE3DU;   /* 0b11000010101100101010111000111101 */
+static const xxh_u32 XXH_PRIME32_4 = 0x27D4EB2FU;   /* 0b00100111110101001110101100101111 */
+static const xxh_u32 XXH_PRIME32_5 = 0x165667B1U;   /* 0b00010110010101100110011110110001 */
+
+#ifdef XXH_OLD_NAMES
+#  define PRIME32_1 XXH_PRIME32_1
+#  define PRIME32_2 XXH_PRIME32_2
+#  define PRIME32_3 XXH_PRIME32_3
+#  define PRIME32_4 XXH_PRIME32_4
+#  define PRIME32_5 XXH_PRIME32_5
+#endif
+
+static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
+{
+    acc += input * XXH_PRIME32_2;
+    acc  = XXH_rotl32(acc, 13);
+    acc *= XXH_PRIME32_1;
+#if defined(__GNUC__) && defined(__SSE4_1__) && !defined(XXH_ENABLE_AUTOVECTORIZE)
+    /*
+     * UGLY HACK:
+     * This inline assembly hack forces acc into a normal register. This is the
+     * only thing that prevents GCC and Clang from autovectorizing the XXH32
+     * loop (pragmas and attributes don't work for some resason) without globally
+     * disabling SSE4.1.
+     *
+     * The reason we want to avoid vectorization is because despite working on
+     * 4 integers at a time, there are multiple factors slowing XXH32 down on
+     * SSE4:
+     * - There's a ridiculous amount of lag from pmulld (10 cycles of latency on
+     *   newer chips!) making it slightly slower to multiply four integers at
+     *   once compared to four integers independently. Even when pmulld was
+     *   fastest, Sandy/Ivy Bridge, it is still not worth it to go into SSE
+     *   just to multiply unless doing a long operation.
+     *
+     * - Four instructions are required to rotate,
+     *      movqda tmp,  v // not required with VEX encoding
+     *      pslld  tmp, 13 // tmp <<= 13
+     *      psrld  v,   19 // x >>= 19
+     *      por    v,  tmp // x |= tmp
+     *   compared to one for scalar:
+     *      roll   v, 13    // reliably fast across the board
+     *      shldl  v, v, 13 // Sandy Bridge and later prefer this for some reason
+     *
+     * - Instruction level parallelism is actually more beneficial here because
+     *   the SIMD actually serializes this operation: While v1 is rotating, v2
+     *   can load data, while v3 can multiply. SSE forces them to operate
+     *   together.
+     *
+     * How this hack works:
+     * __asm__(""       // Declare an assembly block but don't declare any instructions
+     *          :       // However, as an Input/Output Operand,
+     *          "+r"    // constrain a read/write operand (+) as a general purpose register (r).
+     *          (acc)   // and set acc as the operand
+     * );
+     *
+     * Because of the 'r', the compiler has promised that seed will be in a
+     * general purpose register and the '+' says that it will be 'read/write',
+     * so it has to assume it has changed. It is like volatile without all the
+     * loads and stores.
+     *
+     * Since the argument has to be in a normal register (not an SSE register),
+     * each time XXH32_round is called, it is impossible to vectorize.
+     */
+    __asm__("" : "+r" (acc));
+#endif
+    return acc;
+}
+
+/* mix all bits */
+static xxh_u32 XXH32_avalanche(xxh_u32 h32)
+{
+    h32 ^= h32 >> 15;
+    h32 *= XXH_PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= XXH_PRIME32_3;
+    h32 ^= h32 >> 16;
+    return(h32);
+}
+
+#define XXH_get32bits(p) XXH_readLE32_align(p, align)
+
+static xxh_u32
+XXH32_finalize(xxh_u32 h32, const xxh_u8* ptr, size_t len, XXH_alignment align)
+{
+#define XXH_PROCESS1 do {                           \
+    h32 += (*ptr++) * XXH_PRIME32_5;                \
+    h32 = XXH_rotl32(h32, 11) * XXH_PRIME32_1;      \
+} while (0)
+
+#define XXH_PROCESS4 do {                           \
+    h32 += XXH_get32bits(ptr) * XXH_PRIME32_3;      \
+    ptr += 4;                                   \
+    h32  = XXH_rotl32(h32, 17) * XXH_PRIME32_4;     \
+} while (0)
+
+    /* Compact rerolled version */
+    if (XXH_REROLL) {
+        len &= 15;
+        while (len >= 4) {
+            XXH_PROCESS4;
+            len -= 4;
+        }
+        while (len > 0) {
+            XXH_PROCESS1;
+            --len;
+        }
+        return XXH32_avalanche(h32);
+    } else {
+         switch(len&15) /* or switch(bEnd - p) */ {
+           case 12:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 8:       XXH_PROCESS4;
+                         /* fallthrough */
+           case 4:       XXH_PROCESS4;
+                         return XXH32_avalanche(h32);
+
+           case 13:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 9:       XXH_PROCESS4;
+                         /* fallthrough */
+           case 5:       XXH_PROCESS4;
+                         XXH_PROCESS1;
+                         return XXH32_avalanche(h32);
+
+           case 14:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 10:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 6:       XXH_PROCESS4;
+                         XXH_PROCESS1;
+                         XXH_PROCESS1;
+                         return XXH32_avalanche(h32);
+
+           case 15:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 11:      XXH_PROCESS4;
+                         /* fallthrough */
+           case 7:       XXH_PROCESS4;
+                         /* fallthrough */
+           case 3:       XXH_PROCESS1;
+                         /* fallthrough */
+           case 2:       XXH_PROCESS1;
+                         /* fallthrough */
+           case 1:       XXH_PROCESS1;
+                         /* fallthrough */
+           case 0:       return XXH32_avalanche(h32);
+        }
+        XXH_ASSERT(0);
+        return h32;   /* reaching this point is deemed impossible */
+    }
+}
+
+#ifdef XXH_OLD_NAMES
+#  define PROCESS1 XXH_PROCESS1
+#  define PROCESS4 XXH_PROCESS4
+#else
+#  undef XXH_PROCESS1
+#  undef XXH_PROCESS4
+#endif
+
+XXH_FORCE_INLINE xxh_u32
+XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align)
+{
+    const xxh_u8* bEnd = input + len;
+    xxh_u32 h32;
+
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+    if (input==NULL) {
+        len=0;
+        bEnd=input=(const xxh_u8*)(size_t)16;
+    }
+#endif
+
+    if (len>=16) {
+        const xxh_u8* const limit = bEnd - 15;
+        xxh_u32 v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
+        xxh_u32 v2 = seed + XXH_PRIME32_2;
+        xxh_u32 v3 = seed + 0;
+        xxh_u32 v4 = seed - XXH_PRIME32_1;
+
+        do {
+            v1 = XXH32_round(v1, XXH_get32bits(input)); input += 4;
+            v2 = XXH32_round(v2, XXH_get32bits(input)); input += 4;
+            v3 = XXH32_round(v3, XXH_get32bits(input)); input += 4;
+            v4 = XXH32_round(v4, XXH_get32bits(input)); input += 4;
+        } while (input < limit);
+
+        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
+            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+    } else {
+        h32  = seed + XXH_PRIME32_5;
+    }
+
+    h32 += (xxh_u32)len;
+
+    return XXH32_finalize(h32, input, len&15, align);
+}
+
+
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH32_state_t state;
+    XXH32_reset(&state, seed);
+    XXH32_update(&state, (const xxh_u8*)input, len);
+    return XXH32_digest(&state);
+
+#else
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
+            return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);
+    }   }
+
+    return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);
+#endif
+}
+
+
+
+/*******   Hash streaming   *******/
+
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
+{
+    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed)
+{
+    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
+    state.v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
+    state.v2 = seed + XXH_PRIME32_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - XXH_PRIME32_1;
+    /* do not write into reserved, planned to be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
+    return XXH_OK;
+}
+
+
+XXH_PUBLIC_API XXH_errorcode
+XXH32_update(XXH32_state_t* state, const void* input, size_t len)
+{
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
+#endif
+
+    {   const xxh_u8* p = (const xxh_u8*)input;
+        const xxh_u8* const bEnd = p + len;
+
+        state->total_len_32 += (XXH32_hash_t)len;
+        state->large_len |= (XXH32_hash_t)((len>=16) | (state->total_len_32>=16));
+
+        if (state->memsize + len < 16)  {   /* fill in tmp buffer */
+            XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, len);
+            state->memsize += (XXH32_hash_t)len;
+            return XXH_OK;
+        }
+
+        if (state->memsize) {   /* some data left from previous update */
+            XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, 16-state->memsize);
+            {   const xxh_u32* p32 = state->mem32;
+                state->v1 = XXH32_round(state->v1, XXH_readLE32(p32)); p32++;
+                state->v2 = XXH32_round(state->v2, XXH_readLE32(p32)); p32++;
+                state->v3 = XXH32_round(state->v3, XXH_readLE32(p32)); p32++;
+                state->v4 = XXH32_round(state->v4, XXH_readLE32(p32));
+            }
+            p += 16-state->memsize;
+            state->memsize = 0;
+        }
+
+        if (p <= bEnd-16) {
+            const xxh_u8* const limit = bEnd - 16;
+            xxh_u32 v1 = state->v1;
+            xxh_u32 v2 = state->v2;
+            xxh_u32 v3 = state->v3;
+            xxh_u32 v4 = state->v4;
+
+            do {
+                v1 = XXH32_round(v1, XXH_readLE32(p)); p+=4;
+                v2 = XXH32_round(v2, XXH_readLE32(p)); p+=4;
+                v3 = XXH32_round(v3, XXH_readLE32(p)); p+=4;
+                v4 = XXH32_round(v4, XXH_readLE32(p)); p+=4;
+            } while (p<=limit);
+
+            state->v1 = v1;
+            state->v2 = v2;
+            state->v3 = v3;
+            state->v4 = v4;
+        }
+
+        if (p < bEnd) {
+            XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
+            state->memsize = (unsigned)(bEnd-p);
+        }
+    }
+
+    return XXH_OK;
+}
+
+
+XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* state)
+{
+    xxh_u32 h32;
+
+    if (state->large_len) {
+        h32 = XXH_rotl32(state->v1, 1)
+            + XXH_rotl32(state->v2, 7)
+            + XXH_rotl32(state->v3, 12)
+            + XXH_rotl32(state->v4, 18);
+    } else {
+        h32 = state->v3 /* == seed */ + XXH_PRIME32_5;
+    }
+
+    h32 += state->total_len_32;
+
+    return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);
+}
+
+
+/*******   Canonical representation   *******/
+
+/*
+ * The default return values from XXH functions are unsigned 32 and 64 bit
+ * integers.
+ *
+ * The canonical representation uses big endian convention, the same convention
+ * as human-readable numbers (large digits first).
+ *
+ * This way, hash values can be written into a file or buffer, remaining
+ * comparable across different systems.
+ *
+ * The following functions allow transformation of hash values to and from their
+ * canonical format.
+ */
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
+{
+    return XXH_readBE32(src);
+}
+
+
+#ifndef XXH_NO_LONG_LONG
+
+/* *******************************************************************
+*  64-bit hash functions
+*********************************************************************/
+
+/*******   Memory access   *******/
+
+typedef XXH64_hash_t xxh_u64;
+
+#ifdef XXH_OLD_NAMES
+#  define U64 xxh_u64
+#endif
+
+/*!
+ * XXH_REROLL_XXH64:
+ * Whether to reroll the XXH64_finalize() loop.
+ *
+ * Just like XXH32, we can unroll the XXH64_finalize() loop. This can be a
+ * performance gain on 64-bit hosts, as only one jump is required.
+ *
+ * However, on 32-bit hosts, because arithmetic needs to be done with two 32-bit
+ * registers, and 64-bit arithmetic needs to be simulated, it isn't beneficial
+ * to unroll. The code becomes ridiculously large (the largest function in the
+ * binary on i386!), and rerolling it saves anywhere from 3kB to 20kB. It is
+ * also slightly faster because it fits into cache better and is more likely
+ * to be inlined by the compiler.
+ *
+ * If XXH_REROLL is defined, this is ignored and the loop is always rerolled.
+ */
+#ifndef XXH_REROLL_XXH64
+#  if (defined(__ILP32__) || defined(_ILP32)) /* ILP32 is often defined on 32-bit GCC family */ \
+   || !(defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) /* x86-64 */ \
+     || defined(_M_ARM64) || defined(__aarch64__) || defined(__arm64__) /* aarch64 */ \
+     || defined(__PPC64__) || defined(__PPC64LE__) || defined(__ppc64__) || defined(__powerpc64__) /* ppc64 */ \
+     || defined(__mips64__) || defined(__mips64)) /* mips64 */ \
+   || (!defined(SIZE_MAX) || SIZE_MAX < ULLONG_MAX) /* check limits */
+#    define XXH_REROLL_XXH64 1
+#  else
+#    define XXH_REROLL_XXH64 0
+#  endif
+#endif /* !defined(XXH_REROLL_XXH64) */
+
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))
+/*
+ * Manual byteshift. Best for old compilers which don't inline memcpy.
+ * We actually directly use XXH_readLE64 and XXH_readBE64.
+ */
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
+
+/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
+static xxh_u64 XXH_read64(const void* memPtr) { return *(const xxh_u64*) memPtr; }
+
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
+
+/*
+ * __pack instructions are safer, but compiler specific, hence potentially
+ * problematic for some compilers.
+ *
+ * Currently only defined for GCC and ICC.
+ */
+#ifdef XXH_OLD_NAMES
+typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) unalign64;
+#endif
+static xxh_u64 XXH_read64(const void* ptr)
+{
+    typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) xxh_unalign64;
+    return ((const xxh_unalign64*)ptr)->u64;
+}
+
+#else
+
+/*
+ * Portable and safe solution. Generally efficient.
+ * see: https://stackoverflow.com/a/32095106/646947
+ */
+static xxh_u64 XXH_read64(const void* memPtr)
+{
+    xxh_u64 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
+
+#if defined(_MSC_VER)     /* Visual Studio */
+#  define XXH_swap64 _byteswap_uint64
+#elif XXH_GCC_VERSION >= 403
+#  define XXH_swap64 __builtin_bswap64
+#else
+static xxh_u64 XXH_swap64 (xxh_u64 x)
+{
+    return  ((x << 56) & 0xff00000000000000ULL) |
+            ((x << 40) & 0x00ff000000000000ULL) |
+            ((x << 24) & 0x0000ff0000000000ULL) |
+            ((x << 8)  & 0x000000ff00000000ULL) |
+            ((x >> 8)  & 0x00000000ff000000ULL) |
+            ((x >> 24) & 0x0000000000ff0000ULL) |
+            ((x >> 40) & 0x000000000000ff00ULL) |
+            ((x >> 56) & 0x00000000000000ffULL);
+}
+#endif
+
+
+/* XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load. */
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))
+
+XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr)
+{
+    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;
+    return bytePtr[0]
+         | ((xxh_u64)bytePtr[1] << 8)
+         | ((xxh_u64)bytePtr[2] << 16)
+         | ((xxh_u64)bytePtr[3] << 24)
+         | ((xxh_u64)bytePtr[4] << 32)
+         | ((xxh_u64)bytePtr[5] << 40)
+         | ((xxh_u64)bytePtr[6] << 48)
+         | ((xxh_u64)bytePtr[7] << 56);
+}
+
+XXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr)
+{
+    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;
+    return bytePtr[7]
+         | ((xxh_u64)bytePtr[6] << 8)
+         | ((xxh_u64)bytePtr[5] << 16)
+         | ((xxh_u64)bytePtr[4] << 24)
+         | ((xxh_u64)bytePtr[3] << 32)
+         | ((xxh_u64)bytePtr[2] << 40)
+         | ((xxh_u64)bytePtr[1] << 48)
+         | ((xxh_u64)bytePtr[0] << 56);
+}
+
+#else
+XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
+}
+
+static xxh_u64 XXH_readBE64(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
+}
+#endif
+
+XXH_FORCE_INLINE xxh_u64
+XXH_readLE64_align(const void* ptr, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return XXH_readLE64(ptr);
+    else
+        return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u64*)ptr : XXH_swap64(*(const xxh_u64*)ptr);
+}
+
+
+/*******   xxh64   *******/
+
+static const xxh_u64 XXH_PRIME64_1 = 0x9E3779B185EBCA87ULL;   /* 0b1001111000110111011110011011000110000101111010111100101010000111 */
+static const xxh_u64 XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4FULL;   /* 0b1100001010110010101011100011110100100111110101001110101101001111 */
+static const xxh_u64 XXH_PRIME64_3 = 0x165667B19E3779F9ULL;   /* 0b0001011001010110011001111011000110011110001101110111100111111001 */
+static const xxh_u64 XXH_PRIME64_4 = 0x85EBCA77C2B2AE63ULL;   /* 0b1000010111101011110010100111011111000010101100101010111001100011 */
+static const xxh_u64 XXH_PRIME64_5 = 0x27D4EB2F165667C5ULL;   /* 0b0010011111010100111010110010111100010110010101100110011111000101 */
+
+#ifdef XXH_OLD_NAMES
+#  define PRIME64_1 XXH_PRIME64_1
+#  define PRIME64_2 XXH_PRIME64_2
+#  define PRIME64_3 XXH_PRIME64_3
+#  define PRIME64_4 XXH_PRIME64_4
+#  define PRIME64_5 XXH_PRIME64_5
+#endif
+
+static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
+{
+    acc += input * XXH_PRIME64_2;
+    acc  = XXH_rotl64(acc, 31);
+    acc *= XXH_PRIME64_1;
+    return acc;
+}
+
+static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)
+{
+    val  = XXH64_round(0, val);
+    acc ^= val;
+    acc  = acc * XXH_PRIME64_1 + XXH_PRIME64_4;
+    return acc;
+}
+
+static xxh_u64 XXH64_avalanche(xxh_u64 h64)
+{
+    h64 ^= h64 >> 33;
+    h64 *= XXH_PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= XXH_PRIME64_3;
+    h64 ^= h64 >> 32;
+    return h64;
+}
+
+
+#define XXH_get64bits(p) XXH_readLE64_align(p, align)
+
+static xxh_u64
+XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len, XXH_alignment align)
+{
+#define XXH_PROCESS1_64 do {                                   \
+    h64 ^= (*ptr++) * XXH_PRIME64_5;                           \
+    h64 = XXH_rotl64(h64, 11) * XXH_PRIME64_1;                 \
+} while (0)
+
+#define XXH_PROCESS4_64 do {                                   \
+    h64 ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;      \
+    ptr += 4;                                              \
+    h64 = XXH_rotl64(h64, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;     \
+} while (0)
+
+#define XXH_PROCESS8_64 do {                                   \
+    xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr)); \
+    ptr += 8;                                              \
+    h64 ^= k1;                                             \
+    h64  = XXH_rotl64(h64,27) * XXH_PRIME64_1 + XXH_PRIME64_4;     \
+} while (0)
+
+    /* Rerolled version for 32-bit targets is faster and much smaller. */
+    if (XXH_REROLL || XXH_REROLL_XXH64) {
+        len &= 31;
+        while (len >= 8) {
+            XXH_PROCESS8_64;
+            len -= 8;
+        }
+        if (len >= 4) {
+            XXH_PROCESS4_64;
+            len -= 4;
+        }
+        while (len > 0) {
+            XXH_PROCESS1_64;
+            --len;
+        }
+         return  XXH64_avalanche(h64);
+    } else {
+        switch(len & 31) {
+           case 24: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 16: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  8: XXH_PROCESS8_64;
+                    return XXH64_avalanche(h64);
+
+           case 28: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 20: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 12: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  4: XXH_PROCESS4_64;
+                    return XXH64_avalanche(h64);
+
+           case 25: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 17: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  9: XXH_PROCESS8_64;
+                    XXH_PROCESS1_64;
+                    return XXH64_avalanche(h64);
+
+           case 29: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 21: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 13: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  5: XXH_PROCESS4_64;
+                    XXH_PROCESS1_64;
+                    return XXH64_avalanche(h64);
+
+           case 26: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 18: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 10: XXH_PROCESS8_64;
+                    XXH_PROCESS1_64;
+                    XXH_PROCESS1_64;
+                    return XXH64_avalanche(h64);
+
+           case 30: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 22: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 14: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  6: XXH_PROCESS4_64;
+                    XXH_PROCESS1_64;
+                    XXH_PROCESS1_64;
+                    return XXH64_avalanche(h64);
+
+           case 27: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 19: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 11: XXH_PROCESS8_64;
+                    XXH_PROCESS1_64;
+                    XXH_PROCESS1_64;
+                    XXH_PROCESS1_64;
+                    return XXH64_avalanche(h64);
+
+           case 31: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 23: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case 15: XXH_PROCESS8_64;
+                         /* fallthrough */
+           case  7: XXH_PROCESS4_64;
+                         /* fallthrough */
+           case  3: XXH_PROCESS1_64;
+                         /* fallthrough */
+           case  2: XXH_PROCESS1_64;
+                         /* fallthrough */
+           case  1: XXH_PROCESS1_64;
+                         /* fallthrough */
+           case  0: return XXH64_avalanche(h64);
+        }
+    }
+    /* impossible to reach */
+    XXH_ASSERT(0);
+    return 0;  /* unreachable, but some compilers complain without it */
+}
+
+#ifdef XXH_OLD_NAMES
+#  define PROCESS1_64 XXH_PROCESS1_64
+#  define PROCESS4_64 XXH_PROCESS4_64
+#  define PROCESS8_64 XXH_PROCESS8_64
+#else
+#  undef XXH_PROCESS1_64
+#  undef XXH_PROCESS4_64
+#  undef XXH_PROCESS8_64
+#endif
+
+XXH_FORCE_INLINE xxh_u64
+XXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment align)
+{
+    const xxh_u8* bEnd = input + len;
+    xxh_u64 h64;
+
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+    if (input==NULL) {
+        len=0;
+        bEnd=input=(const xxh_u8*)(size_t)32;
+    }
+#endif
+
+    if (len>=32) {
+        const xxh_u8* const limit = bEnd - 32;
+        xxh_u64 v1 = seed + XXH_PRIME64_1 + XXH_PRIME64_2;
+        xxh_u64 v2 = seed + XXH_PRIME64_2;
+        xxh_u64 v3 = seed + 0;
+        xxh_u64 v4 = seed - XXH_PRIME64_1;
+
+        do {
+            v1 = XXH64_round(v1, XXH_get64bits(input)); input+=8;
+            v2 = XXH64_round(v2, XXH_get64bits(input)); input+=8;
+            v3 = XXH64_round(v3, XXH_get64bits(input)); input+=8;
+            v4 = XXH64_round(v4, XXH_get64bits(input)); input+=8;
+        } while (input<=limit);
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+
+    } else {
+        h64  = seed + XXH_PRIME64_5;
+    }
+
+    h64 += (xxh_u64) len;
+
+    return XXH64_finalize(h64, input, len, align);
+}
+
+
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t len, XXH64_hash_t seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH64_state_t state;
+    XXH64_reset(&state, seed);
+    XXH64_update(&state, (const xxh_u8*)input, len);
+    return XXH64_digest(&state);
+
+#else
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
+            return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);
+    }   }
+
+    return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);
+
+#endif
+}
+
+/*******   Hash Streaming   *******/
+
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
+{
+    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_hash_t seed)
+{
+    XXH64_state_t state;   /* use a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
+    state.v1 = seed + XXH_PRIME64_1 + XXH_PRIME64_2;
+    state.v2 = seed + XXH_PRIME64_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - XXH_PRIME64_1;
+     /* do not write into reserved64, might be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved64));
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH64_update (XXH64_state_t* state, const void* input, size_t len)
+{
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
+#endif
+
+    {   const xxh_u8* p = (const xxh_u8*)input;
+        const xxh_u8* const bEnd = p + len;
+
+        state->total_len += len;
+
+        if (state->memsize + len < 32) {  /* fill in tmp buffer */
+            XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, len);
+            state->memsize += (xxh_u32)len;
+            return XXH_OK;
+        }
+
+        if (state->memsize) {   /* tmp buffer is full */
+            XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, 32-state->memsize);
+            state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0));
+            state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1));
+            state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2));
+            state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3));
+            p += 32-state->memsize;
+            state->memsize = 0;
+        }
+
+        if (p+32 <= bEnd) {
+            const xxh_u8* const limit = bEnd - 32;
+            xxh_u64 v1 = state->v1;
+            xxh_u64 v2 = state->v2;
+            xxh_u64 v3 = state->v3;
+            xxh_u64 v4 = state->v4;
+
+            do {
+                v1 = XXH64_round(v1, XXH_readLE64(p)); p+=8;
+                v2 = XXH64_round(v2, XXH_readLE64(p)); p+=8;
+                v3 = XXH64_round(v3, XXH_readLE64(p)); p+=8;
+                v4 = XXH64_round(v4, XXH_readLE64(p)); p+=8;
+            } while (p<=limit);
+
+            state->v1 = v1;
+            state->v2 = v2;
+            state->v3 = v3;
+            state->v4 = v4;
+        }
+
+        if (p < bEnd) {
+            XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
+            state->memsize = (unsigned)(bEnd-p);
+        }
+    }
+
+    return XXH_OK;
+}
+
+
+XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* state)
+{
+    xxh_u64 h64;
+
+    if (state->total_len >= 32) {
+        xxh_u64 const v1 = state->v1;
+        xxh_u64 const v2 = state->v2;
+        xxh_u64 const v3 = state->v3;
+        xxh_u64 const v4 = state->v4;
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+    } else {
+        h64  = state->v3 /*seed*/ + XXH_PRIME64_5;
+    }
+
+    h64 += (xxh_u64) state->total_len;
+
+    return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned);
+}
+
+
+/******* Canonical representation   *******/
+
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
+{
+    return XXH_readBE64(src);
+}
+
+
+
+/* *********************************************************************
+*  XXH3
+*  New generation hash designed for speed on small keys and vectorization
+************************************************************************ */
+
+/* ===   Compiler specifics   === */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* >= C99 */
+#  define XXH_RESTRICT   restrict
+#else
+/* Note: it might be useful to define __restrict or __restrict__ for some C++ compilers */
+#  define XXH_RESTRICT   /* disable */
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ >= 3))  \
+  || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) \
+  || defined(__clang__)
+#    define XXH_likely(x) __builtin_expect(x, 1)
+#    define XXH_unlikely(x) __builtin_expect(x, 0)
+#else
+#    define XXH_likely(x) (x)
+#    define XXH_unlikely(x) (x)
+#endif
+
+#if defined(__GNUC__)
+#  if defined(__AVX2__)
+#    include <immintrin.h>
+#  elif defined(__SSE2__)
+#    include <emmintrin.h>
+#  elif defined(__ARM_NEON__) || defined(__ARM_NEON)
+#    define inline __inline__  /* circumvent a clang bug */
+#    include <arm_neon.h>
+#    undef inline
+#  endif
+#elif defined(_MSC_VER)
+#  include <intrin.h>
+#endif
+
+/*
+ * One goal of XXH3 is to make it fast on both 32-bit and 64-bit, while
+ * remaining a true 64-bit/128-bit hash function.
+ *
+ * This is done by prioritizing a subset of 64-bit operations that can be
+ * emulated without too many steps on the average 32-bit machine.
+ *
+ * For example, these two lines seem similar, and run equally fast on 64-bit:
+ *
+ *   xxh_u64 x;
+ *   x ^= (x >> 47); // good
+ *   x ^= (x >> 13); // bad
+ *
+ * However, to a 32-bit machine, there is a major difference.
+ *
+ * x ^= (x >> 47) looks like this:
+ *
+ *   x.lo ^= (x.hi >> (47 - 32));
+ *
+ * while x ^= (x >> 13) looks like this:
+ *
+ *   // note: funnel shifts are not usually cheap.
+ *   x.lo ^= (x.lo >> 13) | (x.hi << (32 - 13));
+ *   x.hi ^= (x.hi >> 13);
+ *
+ * The first one is significantly faster than the second, simply because the
+ * shift is larger than 32. This means:
+ *  - All the bits we need are in the upper 32 bits, so we can ignore the lower
+ *    32 bits in the shift.
+ *  - The shift result will always fit in the lower 32 bits, and therefore,
+ *    we can ignore the upper 32 bits in the xor.
+ *
+ * Thanks to this optimization, XXH3 only requires these features to be efficient:
+ *
+ *  - Usable unaligned access
+ *  - A 32-bit or 64-bit ALU
+ *      - If 32-bit, a decent ADC instruction
+ *  - A 32 or 64-bit multiply with a 64-bit result
+ *  - For the 128-bit variant, a decent byteswap helps short inputs.
+ *
+ * The first two are already required by XXH32, and almost all 32-bit and 64-bit
+ * platforms which can run XXH32 can run XXH3 efficiently.
+ *
+ * Thumb-1, the classic 16-bit only subset of ARM's instruction set, is one
+ * notable exception.
+ *
+ * First of all, Thumb-1 lacks support for the UMULL instruction which
+ * performs the important long multiply. This means numerous __aeabi_lmul
+ * calls.
+ *
+ * Second of all, the 8 functional registers are just not enough.
+ * Setup for __aeabi_lmul, byteshift loads, pointers, and all arithmetic need
+ * Lo registers, and this shuffling results in thousands more MOVs than A32.
+ *
+ * A32 and T32 don't have this limitation. They can access all 14 registers,
+ * do a 32->64 multiply with UMULL, and the flexible operand allowing free
+ * shifts is helpful, too.
+ *
+ * Therefore, we do a quick sanity check.
+ *
+ * If compiling Thumb-1 for a target which supports ARM instructions, we will
+ * emit a warning, as it is not a "sane" platform to compile for.
+ *
+ * Usually, if this happens, it is because of an accident and you probably need
+ * to specify -march, as you likely meant to compile for a newer architecture.
+ *
+ * Credit: large sections of the vectorial and asm source code paths
+ *         have been contributed by @easyaspi314
+ */
+#if defined(__thumb__) && !defined(__thumb2__) && defined(__ARM_ARCH_ISA_ARM)
+#   warning "XXH3 is highly inefficient without ARM or Thumb-2."
+#endif
+
+/* ==========================================
+ * Vectorization detection
+ * ========================================== */
+#define XXH_SCALAR 0  /* Portable scalar version */
+#define XXH_SSE2   1  /* SSE2 for Pentium 4 and all x86_64 */
+#define XXH_AVX2   2  /* AVX2 for Haswell and Bulldozer */
+#define XXH_AVX512 3  /* AVX512 for Skylake and Icelake */
+#define XXH_NEON   4  /* NEON for most ARMv7-A and all AArch64 */
+#define XXH_VSX    5  /* VSX and ZVector for POWER8/z13 */
+
+#ifndef XXH_VECTOR    /* can be defined on command line */
+#  if defined(__AVX512F__)
+#    define XXH_VECTOR XXH_AVX512
+#  elif defined(__AVX2__)
+#    define XXH_VECTOR XXH_AVX2
+#  elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))
+#    define XXH_VECTOR XXH_SSE2
+#  elif defined(__GNUC__) /* msvc support maybe later */ \
+  && (defined(__ARM_NEON__) || defined(__ARM_NEON)) \
+  && (defined(__LITTLE_ENDIAN__) /* We only support little endian NEON */ \
+    || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+#    define XXH_VECTOR XXH_NEON
+#  elif (defined(__PPC64__) && defined(__POWER8_VECTOR__)) \
+     || (defined(__s390x__) && defined(__VEC__)) \
+     && defined(__GNUC__) /* TODO: IBM XL */
+#    define XXH_VECTOR XXH_VSX
+#  else
+#    define XXH_VECTOR XXH_SCALAR
+#  endif
+#endif
+
+/*
+ * Controls the alignment of the accumulator,
+ * for compatibility with aligned vector loads, which are usually faster.
+ */
+#ifndef XXH_ACC_ALIGN
+#  if defined(XXH_X86DISPATCH)
+#     define XXH_ACC_ALIGN 64  /* for compatibility with avx512 */
+#  elif XXH_VECTOR == XXH_SCALAR  /* scalar */
+#     define XXH_ACC_ALIGN 8
+#  elif XXH_VECTOR == XXH_SSE2  /* sse2 */
+#     define XXH_ACC_ALIGN 16
+#  elif XXH_VECTOR == XXH_AVX2  /* avx2 */
+#     define XXH_ACC_ALIGN 32
+#  elif XXH_VECTOR == XXH_NEON  /* neon */
+#     define XXH_ACC_ALIGN 16
+#  elif XXH_VECTOR == XXH_VSX   /* vsx */
+#     define XXH_ACC_ALIGN 16
+#  elif XXH_VECTOR == XXH_AVX512  /* avx512 */
+#     define XXH_ACC_ALIGN 64
+#  endif
+#endif
+
+#if defined(XXH_X86DISPATCH) || XXH_VECTOR == XXH_SSE2 \
+    || XXH_VECTOR == XXH_AVX2 || XXH_VECTOR == XXH_AVX512
+#  define XXH_SEC_ALIGN XXH_ACC_ALIGN
+#else
+#  define XXH_SEC_ALIGN 8
+#endif
+
+/*
+ * UGLY HACK:
+ * GCC usually generates the best code with -O3 for xxHash.
+ *
+ * However, when targeting AVX2, it is overzealous in its unrolling resulting
+ * in code roughly 3/4 the speed of Clang.
+ *
+ * There are other issues, such as GCC splitting _mm256_loadu_si256 into
+ * _mm_loadu_si128 + _mm256_inserti128_si256. This is an optimization which
+ * only applies to Sandy and Ivy Bridge... which don't even support AVX2.
+ *
+ * That is why when compiling the AVX2 version, it is recommended to use either
+ *   -O2 -mavx2 -march=haswell
+ * or
+ *   -O2 -mavx2 -mno-avx256-split-unaligned-load
+ * for decent performance, or to use Clang instead.
+ *
+ * Fortunately, we can control the first one with a pragma that forces GCC into
+ * -O2, but the other one we can't control without "failed to inline always
+ * inline function due to target mismatch" warnings.
+ */
+#if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \
+  && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
+  && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */
+#  pragma GCC push_options
+#  pragma GCC optimize("-O2")
+#endif
+
+
+#if XXH_VECTOR == XXH_NEON
+/*
+ * NEON's setup for vmlal_u32 is a little more complicated than it is on
+ * SSE2, AVX2, and VSX.
+ *
+ * While PMULUDQ and VMULEUW both perform a mask, VMLAL.U32 performs an upcast.
+ *
+ * To do the same operation, the 128-bit 'Q' register needs to be split into
+ * two 64-bit 'D' registers, performing this operation::
+ *
+ *   [                a                 |                 b                ]
+ *            |              '---------. .--------'                |
+ *            |                         x                          |
+ *            |              .---------' '--------.                |
+ *   [ a & 0xFFFFFFFF | b & 0xFFFFFFFF ],[    a >> 32     |     b >> 32    ]
+ *
+ * Due to significant changes in aarch64, the fastest method for aarch64 is
+ * completely different than the fastest method for ARMv7-A.
+ *
+ * ARMv7-A treats D registers as unions overlaying Q registers, so modifying
+ * D11 will modify the high half of Q5. This is similar to how modifying AH
+ * will only affect bits 8-15 of AX on x86.
+ *
+ * VZIP takes two registers, and puts even lanes in one register and odd lanes
+ * in the other.
+ *
+ * On ARMv7-A, this strangely modifies both parameters in place instead of
+ * taking the usual 3-operand form.
+ *
+ * Therefore, if we want to do this, we can simply use a D-form VZIP.32 on the
+ * lower and upper halves of the Q register to end up with the high and low
+ * halves where we want - all in one instruction.
+ *
+ *   vzip.32   d10, d11       @ d10 = { d10[0], d11[0] }; d11 = { d10[1], d11[1] }
+ *
+ * Unfortunately we need inline assembly for this: Instructions modifying two
+ * registers at once is not possible in GCC or Clang's IR, and they have to
+ * create a copy.
+ *
+ * aarch64 requires a different approach.
+ *
+ * In order to make it easier to write a decent compiler for aarch64, many
+ * quirks were removed, such as conditional execution.
+ *
+ * NEON was also affected by this.
+ *
+ * aarch64 cannot access the high bits of a Q-form register, and writes to a
+ * D-form register zero the high bits, similar to how writes to W-form scalar
+ * registers (or DWORD registers on x86_64) work.
+ *
+ * The formerly free vget_high intrinsics now require a vext (with a few
+ * exceptions)
+ *
+ * Additionally, VZIP was replaced by ZIP1 and ZIP2, which are the equivalent
+ * of PUNPCKL* and PUNPCKH* in SSE, respectively, in order to only modify one
+ * operand.
+ *
+ * The equivalent of the VZIP.32 on the lower and upper halves would be this
+ * mess:
+ *
+ *   ext     v2.4s, v0.4s, v0.4s, #2 // v2 = { v0[2], v0[3], v0[0], v0[1] }
+ *   zip1    v1.2s, v0.2s, v2.2s     // v1 = { v0[0], v2[0] }
+ *   zip2    v0.2s, v0.2s, v1.2s     // v0 = { v0[1], v2[1] }
+ *
+ * Instead, we use a literal downcast, vmovn_u64 (XTN), and vshrn_n_u64 (SHRN):
+ *
+ *   shrn    v1.2s, v0.2d, #32  // v1 = (uint32x2_t)(v0 >> 32);
+ *   xtn     v0.2s, v0.2d       // v0 = (uint32x2_t)(v0 & 0xFFFFFFFF);
+ *
+ * This is available on ARMv7-A, but is less efficient than a single VZIP.32.
+ */
+
+/*
+ * Function-like macro:
+ * void XXH_SPLIT_IN_PLACE(uint64x2_t &in, uint32x2_t &outLo, uint32x2_t &outHi)
+ * {
+ *     outLo = (uint32x2_t)(in & 0xFFFFFFFF);
+ *     outHi = (uint32x2_t)(in >> 32);
+ *     in = UNDEFINED;
+ * }
+ */
+# if !defined(XXH_NO_VZIP_HACK) /* define to disable */ \
+   && defined(__GNUC__) \
+   && !defined(__aarch64__) && !defined(__arm64__)
+#  define XXH_SPLIT_IN_PLACE(in, outLo, outHi)                                              \
+    do {                                                                                    \
+      /* Undocumented GCC/Clang operand modifier: %e0 = lower D half, %f0 = upper D half */ \
+      /* https://github.com/gcc-mirror/gcc/blob/38cf91e5/gcc/config/arm/arm.c#L22486 */     \
+      /* https://github.com/llvm-mirror/llvm/blob/2c4ca683/lib/Target/ARM/ARMAsmPrinter.cpp#L399 */ \
+      __asm__("vzip.32  %e0, %f0" : "+w" (in));                                             \
+      (outLo) = vget_low_u32 (vreinterpretq_u32_u64(in));                                   \
+      (outHi) = vget_high_u32(vreinterpretq_u32_u64(in));                                   \
+   } while (0)
+# else
+#  define XXH_SPLIT_IN_PLACE(in, outLo, outHi)                                            \
+    do {                                                                                  \
+      (outLo) = vmovn_u64    (in);                                                        \
+      (outHi) = vshrn_n_u64  ((in), 32);                                                  \
+    } while (0)
+# endif
+#endif  /* XXH_VECTOR == XXH_NEON */
+
+/*
+ * VSX and Z Vector helpers.
+ *
+ * This is very messy, and any pull requests to clean this up are welcome.
+ *
+ * There are a lot of problems with supporting VSX and s390x, due to
+ * inconsistent intrinsics, spotty coverage, and multiple endiannesses.
+ */
+#if XXH_VECTOR == XXH_VSX
+#  if defined(__s390x__)
+#    include <s390intrin.h>
+#  else
+/* gcc's altivec.h can have the unwanted consequence to unconditionally
+ * #define bool, vector, and pixel keywords,
+ * with bad consequences for programs already using these keywords for other purposes.
+ * The paragraph defining these macros is skipped when __APPLE_ALTIVEC__ is defined.
+ * __APPLE_ALTIVEC__ is _generally_ defined automatically by the compiler,
+ * but it seems that, in some cases, it isn't.
+ * Force the build macro to be defined, so that keywords are not altered.
+ */
+#    if defined(__GNUC__) && !defined(__APPLE_ALTIVEC__)
+#      define __APPLE_ALTIVEC__
+#    endif
+#    include <altivec.h>
+#  endif
+
+typedef __vector unsigned long long xxh_u64x2;
+typedef __vector unsigned char xxh_u8x16;
+typedef __vector unsigned xxh_u32x4;
+
+# ifndef XXH_VSX_BE
+#  if defined(__BIG_ENDIAN__) \
+  || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#    define XXH_VSX_BE 1
+#  elif defined(__VEC_ELEMENT_REG_ORDER__) && __VEC_ELEMENT_REG_ORDER__ == __ORDER_BIG_ENDIAN__
+#    warning "-maltivec=be is not recommended. Please use native endianness."
+#    define XXH_VSX_BE 1
+#  else
+#    define XXH_VSX_BE 0
+#  endif
+# endif /* !defined(XXH_VSX_BE) */
+
+# if XXH_VSX_BE
+/* A wrapper for POWER9's vec_revb. */
+#  if defined(__POWER9_VECTOR__) || (defined(__clang__) && defined(__s390x__))
+#    define XXH_vec_revb vec_revb
+#  else
+XXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val)
+{
+    xxh_u8x16 const vByteSwap = { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
+                                  0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08 };
+    return vec_perm(val, val, vByteSwap);
+}
+#  endif
+# endif /* XXH_VSX_BE */
+
+/*
+ * Performs an unaligned load and byte swaps it on big endian.
+ */
+XXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)
+{
+    xxh_u64x2 ret;
+    memcpy(&ret, ptr, sizeof(xxh_u64x2));
+# if XXH_VSX_BE
+    ret = XXH_vec_revb(ret);
+# endif
+    return ret;
+}
+
+/*
+ * vec_mulo and vec_mule are very problematic intrinsics on PowerPC
+ *
+ * These intrinsics weren't added until GCC 8, despite existing for a while,
+ * and they are endian dependent. Also, their meaning swap depending on version.
+ * */
+# if defined(__s390x__)
+ /* s390x is always big endian, no issue on this platform */
+#  define XXH_vec_mulo vec_mulo
+#  define XXH_vec_mule vec_mule
+# elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw)
+/* Clang has a better way to control this, we can just use the builtin which doesn't swap. */
+#  define XXH_vec_mulo __builtin_altivec_vmulouw
+#  define XXH_vec_mule __builtin_altivec_vmuleuw
+# else
+/* gcc needs inline assembly */
+/* Adapted from https://github.com/google/highwayhash/blob/master/highwayhash/hh_vsx.h. */
+XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b)
+{
+    xxh_u64x2 result;
+    __asm__("vmulouw %0, %1, %2" : "=v" (result) : "v" (a), "v" (b));
+    return result;
+}
+XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)
+{
+    xxh_u64x2 result;
+    __asm__("vmuleuw %0, %1, %2" : "=v" (result) : "v" (a), "v" (b));
+    return result;
+}
+# endif /* XXH_vec_mulo, XXH_vec_mule */
+#endif /* XXH_VECTOR == XXH_VSX */
+
+
+/* prefetch
+ * can be disabled, by declaring XXH_NO_PREFETCH build macro */
+#if defined(XXH_NO_PREFETCH)
+#  define XXH_PREFETCH(ptr)  (void)(ptr)  /* disabled */
+#else
+#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))  /* _mm_prefetch() is not defined outside of x86/x64 */
+#    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
+#    define XXH_PREFETCH(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
+#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
+#    define XXH_PREFETCH(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)
+#  else
+#    define XXH_PREFETCH(ptr) (void)(ptr)  /* disabled */
+#  endif
+#endif  /* XXH_NO_PREFETCH */
+
+
+/* ==========================================
+ * XXH3 default settings
+ * ========================================== */
+
+#define XXH_SECRET_DEFAULT_SIZE 192   /* minimum XXH3_SECRET_SIZE_MIN */
+
+#if (XXH_SECRET_DEFAULT_SIZE < XXH3_SECRET_SIZE_MIN)
+#  error "default keyset is not large enough"
+#endif
+
+/* Pseudorandom secret taken directly from FARSH */
+XXH_ALIGN(64) static const xxh_u8 XXH3_kSecret[XXH_SECRET_DEFAULT_SIZE] = {
+    0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
+    0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
+    0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
+    0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
+    0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
+    0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
+    0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
+    0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
+    0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
+    0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
+    0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
+    0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
+};
+
+
+#ifdef XXH_OLD_NAMES
+#  define kSecret XXH3_kSecret
+#endif
+
+/*
+ * Calculates a 32-bit to 64-bit long multiply.
+ *
+ * Wraps __emulu on MSVC x86 because it tends to call __allmul when it doesn't
+ * need to (but it shouldn't need to anyways, it is about 7 instructions to do
+ * a 64x64 multiply...). Since we know that this will _always_ emit MULL, we
+ * use that instead of the normal method.
+ *
+ * If you are compiling for platforms like Thumb-1 and don't have a better option,
+ * you may also want to write your own long multiply routine here.
+ *
+ * XXH_FORCE_INLINE xxh_u64 XXH_mult32to64(xxh_u64 x, xxh_u64 y)
+ * {
+ *    return (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF);
+ * }
+ */
+#if defined(_MSC_VER) && defined(_M_IX86)
+#    include <intrin.h>
+#    define XXH_mult32to64(x, y) __emulu((unsigned)(x), (unsigned)(y))
+#else
+/*
+ * Downcast + upcast is usually better than masking on older compilers like
+ * GCC 4.2 (especially 32-bit ones), all without affecting newer compilers.
+ *
+ * The other method, (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF), will AND both operands
+ * and perform a full 64x64 multiply -- entirely redundant on 32-bit.
+ */
+#    define XXH_mult32to64(x, y) ((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y))
+#endif
+
+/*
+ * Calculates a 64->128-bit long multiply.
+ *
+ * Uses __uint128_t and _umul128 if available, otherwise uses a scalar version.
+ */
+static XXH128_hash_t
+XXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)
+{
+    /*
+     * GCC/Clang __uint128_t method.
+     *
+     * On most 64-bit targets, GCC and Clang define a __uint128_t type.
+     * This is usually the best way as it usually uses a native long 64-bit
+     * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64.
+     *
+     * Usually.
+     *
+     * Despite being a 32-bit platform, Clang (and emscripten) define this type
+     * despite not having the arithmetic for it. This results in a laggy
+     * compiler builtin call which calculates a full 128-bit multiply.
+     * In that case it is best to use the portable one.
+     * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677
+     */
+#if defined(__GNUC__) && !defined(__wasm__) \
+    && defined(__SIZEOF_INT128__) \
+    || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
+
+    __uint128_t const product = (__uint128_t)lhs * (__uint128_t)rhs;
+    XXH128_hash_t r128;
+    r128.low64  = (xxh_u64)(product);
+    r128.high64 = (xxh_u64)(product >> 64);
+    return r128;
+
+    /*
+     * MSVC for x64's _umul128 method.
+     *
+     * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct);
+     *
+     * This compiles to single operand MUL on x64.
+     */
+#elif defined(_M_X64) || defined(_M_IA64)
+
+#ifndef _MSC_VER
+#   pragma intrinsic(_umul128)
+#endif
+    xxh_u64 product_high;
+    xxh_u64 const product_low = _umul128(lhs, rhs, &product_high);
+    XXH128_hash_t r128;
+    r128.low64  = product_low;
+    r128.high64 = product_high;
+    return r128;
+
+#else
+    /*
+     * Portable scalar method. Optimized for 32-bit and 64-bit ALUs.
+     *
+     * This is a fast and simple grade school multiply, which is shown below
+     * with base 10 arithmetic instead of base 0x100000000.
+     *
+     *           9 3 // D2 lhs = 93
+     *         x 7 5 // D2 rhs = 75
+     *     ----------
+     *           1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15
+     *         4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45
+     *         2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21
+     *     + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63
+     *     ---------
+     *         2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27
+     *     + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67
+     *     ---------
+     *       6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975
+     *
+     * The reasons for adding the products like this are:
+     *  1. It avoids manual carry tracking. Just like how
+     *     (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX.
+     *     This avoids a lot of complexity.
+     *
+     *  2. It hints for, and on Clang, compiles to, the powerful UMAAL
+     *     instruction available in ARM's Digital Signal Processing extension
+     *     in 32-bit ARMv6 and later, which is shown below:
+     *
+     *         void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm)
+     *         {
+     *             xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm;
+     *             *RdLo = (xxh_u32)(product & 0xFFFFFFFF);
+     *             *RdHi = (xxh_u32)(product >> 32);
+     *         }
+     *
+     *     This instruction was designed for efficient long multiplication, and
+     *     allows this to be calculated in only 4 instructions at speeds
+     *     comparable to some 64-bit ALUs.
+     *
+     *  3. It isn't terrible on other platforms. Usually this will be a couple
+     *     of 32-bit ADD/ADCs.
+     */
+
+    /* First calculate all of the cross products. */
+    xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);
+    xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32,        rhs & 0xFFFFFFFF);
+    xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);
+    xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32,        rhs >> 32);
+
+    /* Now add the products together. These will never overflow. */
+    xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;
+    xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32)        + hi_hi;
+    xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);
+
+    XXH128_hash_t r128;
+    r128.low64  = lower;
+    r128.high64 = upper;
+    return r128;
+#endif
+}
+
+/*
+ * Does a 64-bit to 128-bit multiply, then XOR folds it.
+ *
+ * The reason for the separate function is to prevent passing too many structs
+ * around by value. This will hopefully inline the multiply, but we don't force it.
+ */
+static xxh_u64
+XXH3_mul128_fold64(xxh_u64 lhs, xxh_u64 rhs)
+{
+    XXH128_hash_t product = XXH_mult64to128(lhs, rhs);
+    return product.low64 ^ product.high64;
+}
+
+/* Seems to produce slightly better code on GCC for some reason. */
+XXH_FORCE_INLINE xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
+{
+    XXH_ASSERT(0 <= shift && shift < 64);
+    return v64 ^ (v64 >> shift);
+}
+
+/*
+ * This is a fast avalanche stage,
+ * suitable when input bits are already partially mixed
+ */
+static XXH64_hash_t XXH3_avalanche(xxh_u64 h64)
+{
+    h64 = XXH_xorshift64(h64, 37);
+    h64 *= 0x165667919E3779F9ULL;
+    h64 = XXH_xorshift64(h64, 32);
+    return h64;
+}
+
+/*
+ * This is a stronger avalanche,
+ * inspired by Pelle Evensen's rrmxmx
+ * preferable when input has not been previously mixed
+ */
+static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
+{
+    /* this mix is inspired by Pelle Evensen's rrmxmx */
+    h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);
+    h64 *= 0x9FB21C651E98DF25ULL;
+    h64 ^= (h64 >> 35) + len ;
+    h64 *= 0x9FB21C651E98DF25ULL;
+    return XXH_xorshift64(h64, 28);
+}
+
+
+/* ==========================================
+ * Short keys
+ * ==========================================
+ * One of the shortcomings of XXH32 and XXH64 was that their performance was
+ * sub-optimal on short lengths. It used an iterative algorithm which strongly
+ * favored lengths that were a multiple of 4 or 8.
+ *
+ * Instead of iterating over individual inputs, we use a set of single shot
+ * functions which piece together a range of lengths and operate in constant time.
+ *
+ * Additionally, the number of multiplies has been significantly reduced. This
+ * reduces latency, especially when emulating 64-bit multiplies on 32-bit.
+ *
+ * Depending on the platform, this may or may not be faster than XXH32, but it
+ * is almost guaranteed to be faster than XXH64.
+ */
+
+/*
+ * At very short lengths, there isn't enough input to fully hide secrets, or use
+ * the entire secret.
+ *
+ * There is also only a limited amount of mixing we can do before significantly
+ * impacting performance.
+ *
+ * Therefore, we use different sections of the secret and always mix two secret
+ * samples with an XOR. This should have no effect on performance on the
+ * seedless or withSeed variants because everything _should_ be constant folded
+ * by modern compilers.
+ *
+ * The XOR mixing hides individual parts of the secret and increases entropy.
+ *
+ * This adds an extra layer of strength for custom secrets.
+ */
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(1 <= len && len <= 3);
+    XXH_ASSERT(secret != NULL);
+    /*
+     * len = 1: combined = { input[0], 0x01, input[0], input[0] }
+     * len = 2: combined = { input[1], 0x02, input[0], input[1] }
+     * len = 3: combined = { input[2], 0x03, input[0], input[1] }
+     */
+    {   xxh_u8  const c1 = input[0];
+        xxh_u8  const c2 = input[len >> 1];
+        xxh_u8  const c3 = input[len - 1];
+        xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2  << 24)
+                               | ((xxh_u32)c3 <<  0) | ((xxh_u32)len << 8);
+        xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
+        xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;
+        return XXH64_avalanche(keyed);
+    }
+}
+
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(secret != NULL);
+    XXH_ASSERT(4 <= len && len < 8);
+    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
+    {   xxh_u32 const input1 = XXH_readLE32(input);
+        xxh_u32 const input2 = XXH_readLE32(input + len - 4);
+        xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed;
+        xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32);
+        xxh_u64 const keyed = input64 ^ bitflip;
+        return XXH3_rrmxmx(keyed, len);
+    }
+}
+
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(secret != NULL);
+    XXH_ASSERT(8 <= len && len <= 16);
+    {   xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;
+        xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;
+        xxh_u64 const input_lo = XXH_readLE64(input)           ^ bitflip1;
+        xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2;
+        xxh_u64 const acc = len
+                          + XXH_swap64(input_lo) + input_hi
+                          + XXH3_mul128_fold64(input_lo, input_hi);
+        return XXH3_avalanche(acc);
+    }
+}
+
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(len <= 16);
+    {   if (XXH_likely(len >  8)) return XXH3_len_9to16_64b(input, len, secret, seed);
+        if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed);
+        if (len) return XXH3_len_1to3_64b(input, len, secret, seed);
+        return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64)));
+    }
+}
+
+/*
+ * DISCLAIMER: There are known *seed-dependent* multicollisions here due to
+ * multiplication by zero, affecting hashes of lengths 17 to 240.
+ *
+ * However, they are very unlikely.
+ *
+ * Keep this in mind when using the unseeded XXH3_64bits() variant: As with all
+ * unseeded non-cryptographic hashes, it does not attempt to defend itself
+ * against specially crafted inputs, only random inputs.
+ *
+ * Compared to classic UMAC where a 1 in 2^31 chance of 4 consecutive bytes
+ * cancelling out the secret is taken an arbitrary number of times (addressed
+ * in XXH3_accumulate_512), this collision is very unlikely with random inputs
+ * and/or proper seeding:
+ *
+ * This only has a 1 in 2^63 chance of 8 consecutive bytes cancelling out, in a
+ * function that is only called up to 16 times per hash with up to 240 bytes of
+ * input.
+ *
+ * This is not too bad for a non-cryptographic hash function, especially with
+ * only 64 bit outputs.
+ *
+ * The 128-bit variant (which trades some speed for strength) is NOT affected
+ * by this, although it is always a good idea to use a proper seed if you care
+ * about strength.
+ */
+XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
+                                     const xxh_u8* XXH_RESTRICT secret, xxh_u64 seed64)
+{
+#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
+  && defined(__i386__) && defined(__SSE2__)  /* x86 + SSE2 */ \
+  && !defined(XXH_ENABLE_AUTOVECTORIZE)      /* Define to disable like XXH32 hack */
+    /*
+     * UGLY HACK:
+     * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in
+     * slower code.
+     *
+     * By forcing seed64 into a register, we disrupt the cost model and
+     * cause it to scalarize. See `XXH32_round()`
+     *
+     * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,
+     * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on
+     * GCC 9.2, despite both emitting scalar code.
+     *
+     * GCC generates much better scalar code than Clang for the rest of XXH3,
+     * which is why finding a more optimal codepath is an interest.
+     */
+    __asm__ ("" : "+r" (seed64));
+#endif
+    {   xxh_u64 const input_lo = XXH_readLE64(input);
+        xxh_u64 const input_hi = XXH_readLE64(input+8);
+        return XXH3_mul128_fold64(
+            input_lo ^ (XXH_readLE64(secret)   + seed64),
+            input_hi ^ (XXH_readLE64(secret+8) - seed64)
+        );
+    }
+}
+
+/* For mid range keys, XXH3 uses a Mum-hash variant. */
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
+                     const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                     XXH64_hash_t seed)
+{
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
+    XXH_ASSERT(16 < len && len <= 128);
+
+    {   xxh_u64 acc = len * XXH_PRIME64_1;
+        if (len > 32) {
+            if (len > 64) {
+                if (len > 96) {
+                    acc += XXH3_mix16B(input+48, secret+96, seed);
+                    acc += XXH3_mix16B(input+len-64, secret+112, seed);
+                }
+                acc += XXH3_mix16B(input+32, secret+64, seed);
+                acc += XXH3_mix16B(input+len-48, secret+80, seed);
+            }
+            acc += XXH3_mix16B(input+16, secret+32, seed);
+            acc += XXH3_mix16B(input+len-32, secret+48, seed);
+        }
+        acc += XXH3_mix16B(input+0, secret+0, seed);
+        acc += XXH3_mix16B(input+len-16, secret+16, seed);
+
+        return XXH3_avalanche(acc);
+    }
+}
+
+#define XXH3_MIDSIZE_MAX 240
+
+XXH_NO_INLINE XXH64_hash_t
+XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
+                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                      XXH64_hash_t seed)
+{
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
+    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
+
+    #define XXH3_MIDSIZE_STARTOFFSET 3
+    #define XXH3_MIDSIZE_LASTOFFSET  17
+
+    {   xxh_u64 acc = len * XXH_PRIME64_1;
+        int const nbRounds = (int)len / 16;
+        int i;
+        for (i=0; i<8; i++) {
+            acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed);
+        }
+        acc = XXH3_avalanche(acc);
+        XXH_ASSERT(nbRounds >= 8);
+#if defined(__clang__)                                /* Clang */ \
+    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \
+    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */
+        /*
+         * UGLY HACK:
+         * Clang for ARMv7-A tries to vectorize this loop, similar to GCC x86.
+         * In everywhere else, it uses scalar code.
+         *
+         * For 64->128-bit multiplies, even if the NEON was 100% optimal, it
+         * would still be slower than UMAAL (see XXH_mult64to128).
+         *
+         * Unfortunately, Clang doesn't handle the long multiplies properly and
+         * converts them to the nonexistent "vmulq_u64" intrinsic, which is then
+         * scalarized into an ugly mess of VMOV.32 instructions.
+         *
+         * This mess is difficult to avoid without turning autovectorization
+         * off completely, but they are usually relatively minor and/or not
+         * worth it to fix.
+         *
+         * This loop is the easiest to fix, as unlike XXH32, this pragma
+         * _actually works_ because it is a loop vectorization instead of an
+         * SLP vectorization.
+         */
+        #pragma clang loop vectorize(disable)
+#endif
+        for (i=8 ; i < nbRounds; i++) {
+            acc += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);
+        }
+        /* last bytes */
+        acc += XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);
+        return XXH3_avalanche(acc);
+    }
+}
+
+
+/* =======     Long Keys     ======= */
+
+#define XXH_STRIPE_LEN 64
+#define XXH_SECRET_CONSUME_RATE 8   /* nb of secret bytes consumed at each accumulation */
+#define XXH_ACC_NB (XXH_STRIPE_LEN / sizeof(xxh_u64))
+
+#ifdef XXH_OLD_NAMES
+#  define STRIPE_LEN XXH_STRIPE_LEN
+#  define ACC_NB XXH_ACC_NB
+#endif
+
+XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)
+{
+    if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64);
+    memcpy(dst, &v64, sizeof(v64));
+}
+
+/* Several intrinsic functions below are supposed to accept __int64 as argument,
+ * as documented in https://software.intel.com/sites/landingpage/IntrinsicsGuide/ .
+ * However, several environments do not define __int64 type,
+ * requiring a workaround.
+ */
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+    typedef int64_t xxh_i64;
+#else
+    /* the following type must have a width of 64-bit */
+    typedef long long xxh_i64;
+#endif
+
+/*
+ * XXH3_accumulate_512 is the tightest loop for long inputs, and it is the most optimized.
+ *
+ * It is a hardened version of UMAC, based off of FARSH's implementation.
+ *
+ * This was chosen because it adapts quite well to 32-bit, 64-bit, and SIMD
+ * implementations, and it is ridiculously fast.
+ *
+ * We harden it by mixing the original input to the accumulators as well as the product.
+ *
+ * This means that in the (relatively likely) case of a multiply by zero, the
+ * original input is preserved.
+ *
+ * On 128-bit inputs, we swap 64-bit pairs when we add the input to improve
+ * cross-pollination, as otherwise the upper and lower halves would be
+ * essentially independent.
+ *
+ * This doesn't matter on 64-bit hashes since they all get merged together in
+ * the end, so we skip the extra step.
+ *
+ * Both XXH3_64bits and XXH3_128bits use this subroutine.
+ */
+
+#if (XXH_VECTOR == XXH_AVX512) || defined(XXH_X86DISPATCH)
+
+#ifndef XXH_TARGET_AVX512
+# define XXH_TARGET_AVX512  /* disable attribute target */
+#endif
+
+XXH_FORCE_INLINE XXH_TARGET_AVX512 void
+XXH3_accumulate_512_avx512(void* XXH_RESTRICT acc,
+                     const void* XXH_RESTRICT input,
+                     const void* XXH_RESTRICT secret)
+{
+    XXH_ALIGN(64) __m512i* const xacc = (__m512i *) acc;
+    XXH_ASSERT((((size_t)acc) & 63) == 0);
+    XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));
+
+    {
+        /* data_vec    = input[0]; */
+        __m512i const data_vec    = _mm512_loadu_si512   (input);
+        /* key_vec     = secret[0]; */
+        __m512i const key_vec     = _mm512_loadu_si512   (secret);
+        /* data_key    = data_vec ^ key_vec; */
+        __m512i const data_key    = _mm512_xor_si512     (data_vec, key_vec);
+        /* data_key_lo = data_key >> 32; */
+        __m512i const data_key_lo = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1));
+        /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
+        __m512i const product     = _mm512_mul_epu32     (data_key, data_key_lo);
+        /* xacc[0] += swap(data_vec); */
+        __m512i const data_swap = _mm512_shuffle_epi32(data_vec, (_MM_PERM_ENUM)_MM_SHUFFLE(1, 0, 3, 2));
+        __m512i const sum       = _mm512_add_epi64(*xacc, data_swap);
+        /* xacc[0] += product; */
+        *xacc = _mm512_add_epi64(product, sum);
+    }
+}
+
+/*
+ * XXH3_scrambleAcc: Scrambles the accumulators to improve mixing.
+ *
+ * Multiplication isn't perfect, as explained by Google in HighwayHash:
+ *
+ *  // Multiplication mixes/scrambles bytes 0-7 of the 64-bit result to
+ *  // varying degrees. In descending order of goodness, bytes
+ *  // 3 4 2 5 1 6 0 7 have quality 228 224 164 160 100 96 36 32.
+ *  // As expected, the upper and lower bytes are much worse.
+ *
+ * Source: https://github.com/google/highwayhash/blob/0aaf66b/highwayhash/hh_avx2.h#L291
+ *
+ * Since our algorithm uses a pseudorandom secret to add some variance into the
+ * mix, we don't need to (or want to) mix as often or as much as HighwayHash does.
+ *
+ * This isn't as tight as XXH3_accumulate, but still written in SIMD to avoid
+ * extraction.
+ *
+ * Both XXH3_64bits and XXH3_128bits use this subroutine.
+ */
+
+XXH_FORCE_INLINE XXH_TARGET_AVX512 void
+XXH3_scrambleAcc_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 63) == 0);
+    XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));
+    {   XXH_ALIGN(64) __m512i* const xacc = (__m512i*) acc;
+        const __m512i prime32 = _mm512_set1_epi32((int)XXH_PRIME32_1);
+
+        /* xacc[0] ^= (xacc[0] >> 47) */
+        __m512i const acc_vec     = *xacc;
+        __m512i const shifted     = _mm512_srli_epi64    (acc_vec, 47);
+        __m512i const data_vec    = _mm512_xor_si512     (acc_vec, shifted);
+        /* xacc[0] ^= secret; */
+        __m512i const key_vec     = _mm512_loadu_si512   (secret);
+        __m512i const data_key    = _mm512_xor_si512     (data_vec, key_vec);
+
+        /* xacc[0] *= XXH_PRIME32_1; */
+        __m512i const data_key_hi = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1));
+        __m512i const prod_lo     = _mm512_mul_epu32     (data_key, prime32);
+        __m512i const prod_hi     = _mm512_mul_epu32     (data_key_hi, prime32);
+        *xacc = _mm512_add_epi64(prod_lo, _mm512_slli_epi64(prod_hi, 32));
+    }
+}
+
+XXH_FORCE_INLINE XXH_TARGET_AVX512 void
+XXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
+{
+    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 63) == 0);
+    XXH_STATIC_ASSERT(XXH_SEC_ALIGN == 64);
+    XXH_ASSERT(((size_t)customSecret & 63) == 0);
+    (void)(&XXH_writeLE64);
+    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m512i);
+        __m512i const seed = _mm512_mask_set1_epi64(_mm512_set1_epi64((xxh_i64)seed64), 0xAA, -(xxh_i64)seed64);
+
+        XXH_ALIGN(64) const __m512i* const src  = (const __m512i*) XXH3_kSecret;
+        XXH_ALIGN(64)       __m512i* const dest = (      __m512i*) customSecret;
+        int i;
+        for (i=0; i < nbRounds; ++i) {
+            /* GCC has a bug, _mm512_stream_load_si512 accepts 'void*', not 'void const*',
+             * this will warn "discards ‘const’ qualifier". */
+            union {
+                XXH_ALIGN(64) const __m512i* cp;
+                XXH_ALIGN(64) void* p;
+            } remote_const_void;
+            remote_const_void.cp = src + i;
+            dest[i] = _mm512_add_epi64(_mm512_stream_load_si512(remote_const_void.p), seed);
+    }   }
+}
+
+#endif
+
+#if (XXH_VECTOR == XXH_AVX2) || defined(XXH_X86DISPATCH)
+
+#ifndef XXH_TARGET_AVX2
+# define XXH_TARGET_AVX2  /* disable attribute target */
+#endif
+
+XXH_FORCE_INLINE XXH_TARGET_AVX2 void
+XXH3_accumulate_512_avx2( void* XXH_RESTRICT acc,
+                    const void* XXH_RESTRICT input,
+                    const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 31) == 0);
+    {   XXH_ALIGN(32) __m256i* const xacc    =       (__m256i *) acc;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm256_loadu_si256 requires  a const __m256i * pointer for some reason. */
+        const         __m256i* const xinput  = (const __m256i *) input;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */
+        const         __m256i* const xsecret = (const __m256i *) secret;
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {
+            /* data_vec    = xinput[i]; */
+            __m256i const data_vec    = _mm256_loadu_si256    (xinput+i);
+            /* key_vec     = xsecret[i]; */
+            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);
+            /* data_key    = data_vec ^ key_vec; */
+            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);
+            /* data_key_lo = data_key >> 32; */
+            __m256i const data_key_lo = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
+            __m256i const product     = _mm256_mul_epu32     (data_key, data_key_lo);
+            /* xacc[i] += swap(data_vec); */
+            __m256i const data_swap = _mm256_shuffle_epi32(data_vec, _MM_SHUFFLE(1, 0, 3, 2));
+            __m256i const sum       = _mm256_add_epi64(xacc[i], data_swap);
+            /* xacc[i] += product; */
+            xacc[i] = _mm256_add_epi64(product, sum);
+    }   }
+}
+
+XXH_FORCE_INLINE XXH_TARGET_AVX2 void
+XXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 31) == 0);
+    {   XXH_ALIGN(32) __m256i* const xacc = (__m256i*) acc;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */
+        const         __m256i* const xsecret = (const __m256i *) secret;
+        const __m256i prime32 = _mm256_set1_epi32((int)XXH_PRIME32_1);
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {
+            /* xacc[i] ^= (xacc[i] >> 47) */
+            __m256i const acc_vec     = xacc[i];
+            __m256i const shifted     = _mm256_srli_epi64    (acc_vec, 47);
+            __m256i const data_vec    = _mm256_xor_si256     (acc_vec, shifted);
+            /* xacc[i] ^= xsecret; */
+            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);
+            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);
+
+            /* xacc[i] *= XXH_PRIME32_1; */
+            __m256i const data_key_hi = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            __m256i const prod_lo     = _mm256_mul_epu32     (data_key, prime32);
+            __m256i const prod_hi     = _mm256_mul_epu32     (data_key_hi, prime32);
+            xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32));
+        }
+    }
+}
+
+XXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
+{
+    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 31) == 0);
+    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE / sizeof(__m256i)) == 6);
+    XXH_STATIC_ASSERT(XXH_SEC_ALIGN <= 64);
+    (void)(&XXH_writeLE64);
+    XXH_PREFETCH(customSecret);
+    {   __m256i const seed = _mm256_set_epi64x(-(xxh_i64)seed64, (xxh_i64)seed64, -(xxh_i64)seed64, (xxh_i64)seed64);
+
+        XXH_ALIGN(64) const __m256i* const src  = (const __m256i*) XXH3_kSecret;
+        XXH_ALIGN(64)       __m256i*       dest = (      __m256i*) customSecret;
+
+#       if defined(__GNUC__) || defined(__clang__)
+        /*
+         * On GCC & Clang, marking 'dest' as modified will cause the compiler:
+         *   - do not extract the secret from sse registers in the internal loop
+         *   - use less common registers, and avoid pushing these reg into stack
+         * The asm hack causes Clang to assume that XXH3_kSecretPtr aliases with
+         * customSecret, and on aarch64, this prevented LDP from merging two
+         * loads together for free. Putting the loads together before the stores
+         * properly generates LDP.
+         */
+        __asm__("" : "+r" (dest));
+#       endif
+
+        /* GCC -O2 need unroll loop manually */
+        dest[0] = _mm256_add_epi64(_mm256_stream_load_si256(src+0), seed);
+        dest[1] = _mm256_add_epi64(_mm256_stream_load_si256(src+1), seed);
+        dest[2] = _mm256_add_epi64(_mm256_stream_load_si256(src+2), seed);
+        dest[3] = _mm256_add_epi64(_mm256_stream_load_si256(src+3), seed);
+        dest[4] = _mm256_add_epi64(_mm256_stream_load_si256(src+4), seed);
+        dest[5] = _mm256_add_epi64(_mm256_stream_load_si256(src+5), seed);
+    }
+}
+
+#endif
+
+#if (XXH_VECTOR == XXH_SSE2) || defined(XXH_X86DISPATCH)
+
+#ifndef XXH_TARGET_SSE2
+# define XXH_TARGET_SSE2  /* disable attribute target */
+#endif
+
+XXH_FORCE_INLINE XXH_TARGET_SSE2 void
+XXH3_accumulate_512_sse2( void* XXH_RESTRICT acc,
+                    const void* XXH_RESTRICT input,
+                    const void* XXH_RESTRICT secret)
+{
+    /* SSE2 is just a half-scale version of the AVX2 version. */
+    XXH_ASSERT((((size_t)acc) & 15) == 0);
+    {   XXH_ALIGN(16) __m128i* const xacc    =       (__m128i *) acc;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
+        const         __m128i* const xinput  = (const __m128i *) input;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
+        const         __m128i* const xsecret = (const __m128i *) secret;
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {
+            /* data_vec    = xinput[i]; */
+            __m128i const data_vec    = _mm_loadu_si128   (xinput+i);
+            /* key_vec     = xsecret[i]; */
+            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);
+            /* data_key    = data_vec ^ key_vec; */
+            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);
+            /* data_key_lo = data_key >> 32; */
+            __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
+            __m128i const product     = _mm_mul_epu32     (data_key, data_key_lo);
+            /* xacc[i] += swap(data_vec); */
+            __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2));
+            __m128i const sum       = _mm_add_epi64(xacc[i], data_swap);
+            /* xacc[i] += product; */
+            xacc[i] = _mm_add_epi64(product, sum);
+    }   }
+}
+
+XXH_FORCE_INLINE XXH_TARGET_SSE2 void
+XXH3_scrambleAcc_sse2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 15) == 0);
+    {   XXH_ALIGN(16) __m128i* const xacc = (__m128i*) acc;
+        /* Unaligned. This is mainly for pointer arithmetic, and because
+         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
+        const         __m128i* const xsecret = (const __m128i *) secret;
+        const __m128i prime32 = _mm_set1_epi32((int)XXH_PRIME32_1);
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {
+            /* xacc[i] ^= (xacc[i] >> 47) */
+            __m128i const acc_vec     = xacc[i];
+            __m128i const shifted     = _mm_srli_epi64    (acc_vec, 47);
+            __m128i const data_vec    = _mm_xor_si128     (acc_vec, shifted);
+            /* xacc[i] ^= xsecret[i]; */
+            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);
+            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);
+
+            /* xacc[i] *= XXH_PRIME32_1; */
+            __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            __m128i const prod_lo     = _mm_mul_epu32     (data_key, prime32);
+            __m128i const prod_hi     = _mm_mul_epu32     (data_key_hi, prime32);
+            xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32));
+        }
+    }
+}
+
+XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
+{
+    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);
+    (void)(&XXH_writeLE64);
+    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i);
+
+#       if defined(_MSC_VER) && defined(_M_IX86) && _MSC_VER < 1900
+        // MSVC 32bit mode does not support _mm_set_epi64x before 2015
+        XXH_ALIGN(16) const xxh_i64 seed64x2[2] = { (xxh_i64)seed64, -(xxh_i64)seed64 };
+        __m128i const seed = _mm_load_si128((__m128i const*)seed64x2);
+#       else
+        __m128i const seed = _mm_set_epi64x(-(xxh_i64)seed64, (xxh_i64)seed64);
+#       endif
+        int i;
+
+        XXH_ALIGN(64)        const float* const src  = (float const*) XXH3_kSecret;
+        XXH_ALIGN(XXH_SEC_ALIGN) __m128i*       dest = (__m128i*) customSecret;
+#       if defined(__GNUC__) || defined(__clang__)
+        /*
+         * On GCC & Clang, marking 'dest' as modified will cause the compiler:
+         *   - do not extract the secret from sse registers in the internal loop
+         *   - use less common registers, and avoid pushing these reg into stack
+         */
+        __asm__("" : "+r" (dest));
+#       endif
+
+        for (i=0; i < nbRounds; ++i) {
+            dest[i] = _mm_add_epi64(_mm_castps_si128(_mm_load_ps(src+i*4)), seed);
+    }   }
+}
+
+#endif
+
+#if (XXH_VECTOR == XXH_NEON)
+
+XXH_FORCE_INLINE void
+XXH3_accumulate_512_neon( void* XXH_RESTRICT acc,
+                    const void* XXH_RESTRICT input,
+                    const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 15) == 0);
+    {
+        XXH_ALIGN(16) uint64x2_t* const xacc = (uint64x2_t *) acc;
+        /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */
+        uint8_t const* const xinput = (const uint8_t *) input;
+        uint8_t const* const xsecret  = (const uint8_t *) secret;
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN / sizeof(uint64x2_t); i++) {
+            /* data_vec = xinput[i]; */
+            uint8x16_t data_vec    = vld1q_u8(xinput  + (i * 16));
+            /* key_vec  = xsecret[i];  */
+            uint8x16_t key_vec     = vld1q_u8(xsecret + (i * 16));
+            uint64x2_t data_key;
+            uint32x2_t data_key_lo, data_key_hi;
+            /* xacc[i] += swap(data_vec); */
+            uint64x2_t const data64  = vreinterpretq_u64_u8(data_vec);
+            uint64x2_t const swapped = vextq_u64(data64, data64, 1);
+            xacc[i] = vaddq_u64 (xacc[i], swapped);
+            /* data_key = data_vec ^ key_vec; */
+            data_key = vreinterpretq_u64_u8(veorq_u8(data_vec, key_vec));
+            /* data_key_lo = (uint32x2_t) (data_key & 0xFFFFFFFF);
+             * data_key_hi = (uint32x2_t) (data_key >> 32);
+             * data_key = UNDEFINED; */
+            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
+            /* xacc[i] += (uint64x2_t) data_key_lo * (uint64x2_t) data_key_hi; */
+            xacc[i] = vmlal_u32 (xacc[i], data_key_lo, data_key_hi);
+
+        }
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_scrambleAcc_neon(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 15) == 0);
+
+    {   uint64x2_t* xacc       = (uint64x2_t*) acc;
+        uint8_t const* xsecret = (uint8_t const*) secret;
+        uint32x2_t prime       = vdup_n_u32 (XXH_PRIME32_1);
+
+        size_t i;
+        for (i=0; i < XXH_STRIPE_LEN/sizeof(uint64x2_t); i++) {
+            /* xacc[i] ^= (xacc[i] >> 47); */
+            uint64x2_t acc_vec  = xacc[i];
+            uint64x2_t shifted  = vshrq_n_u64 (acc_vec, 47);
+            uint64x2_t data_vec = veorq_u64   (acc_vec, shifted);
+
+            /* xacc[i] ^= xsecret[i]; */
+            uint8x16_t key_vec  = vld1q_u8(xsecret + (i * 16));
+            uint64x2_t data_key = veorq_u64(data_vec, vreinterpretq_u64_u8(key_vec));
+
+            /* xacc[i] *= XXH_PRIME32_1 */
+            uint32x2_t data_key_lo, data_key_hi;
+            /* data_key_lo = (uint32x2_t) (xacc[i] & 0xFFFFFFFF);
+             * data_key_hi = (uint32x2_t) (xacc[i] >> 32);
+             * xacc[i] = UNDEFINED; */
+            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
+            {   /*
+                 * prod_hi = (data_key >> 32) * XXH_PRIME32_1;
+                 *
+                 * Avoid vmul_u32 + vshll_n_u32 since Clang 6 and 7 will
+                 * incorrectly "optimize" this:
+                 *   tmp     = vmul_u32(vmovn_u64(a), vmovn_u64(b));
+                 *   shifted = vshll_n_u32(tmp, 32);
+                 * to this:
+                 *   tmp     = "vmulq_u64"(a, b); // no such thing!
+                 *   shifted = vshlq_n_u64(tmp, 32);
+                 *
+                 * However, unlike SSE, Clang lacks a 64-bit multiply routine
+                 * for NEON, and it scalarizes two 64-bit multiplies instead.
+                 *
+                 * vmull_u32 has the same timing as vmul_u32, and it avoids
+                 * this bug completely.
+                 * See https://bugs.llvm.org/show_bug.cgi?id=39967
+                 */
+                uint64x2_t prod_hi = vmull_u32 (data_key_hi, prime);
+                /* xacc[i] = prod_hi << 32; */
+                xacc[i] = vshlq_n_u64(prod_hi, 32);
+                /* xacc[i] += (prod_hi & 0xFFFFFFFF) * XXH_PRIME32_1; */
+                xacc[i] = vmlal_u32(xacc[i], data_key_lo, prime);
+            }
+    }   }
+}
+
+#endif
+
+#if (XXH_VECTOR == XXH_VSX)
+
+XXH_FORCE_INLINE void
+XXH3_accumulate_512_vsx(  void* XXH_RESTRICT acc,
+                    const void* XXH_RESTRICT input,
+                    const void* XXH_RESTRICT secret)
+{
+          xxh_u64x2* const xacc     =       (xxh_u64x2*) acc;    /* presumed aligned */
+    xxh_u64x2 const* const xinput   = (xxh_u64x2 const*) input;   /* no alignment restriction */
+    xxh_u64x2 const* const xsecret  = (xxh_u64x2 const*) secret;    /* no alignment restriction */
+    xxh_u64x2 const v32 = { 32, 32 };
+    size_t i;
+    for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {
+        /* data_vec = xinput[i]; */
+        xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + i);
+        /* key_vec = xsecret[i]; */
+        xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
+        xxh_u64x2 const data_key = data_vec ^ key_vec;
+        /* shuffled = (data_key << 32) | (data_key >> 32); */
+        xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32);
+        /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */
+        xxh_u64x2 const product  = XXH_vec_mulo((xxh_u32x4)data_key, shuffled);
+        xacc[i] += product;
+
+        /* swap high and low halves */
+#ifdef __s390x__
+        xacc[i] += vec_permi(data_vec, data_vec, 2);
+#else
+        xacc[i] += vec_xxpermdi(data_vec, data_vec, 2);
+#endif
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ASSERT((((size_t)acc) & 15) == 0);
+
+    {         xxh_u64x2* const xacc    =       (xxh_u64x2*) acc;
+        const xxh_u64x2* const xsecret = (const xxh_u64x2*) secret;
+        /* constants */
+        xxh_u64x2 const v32  = { 32, 32 };
+        xxh_u64x2 const v47 = { 47, 47 };
+        xxh_u32x4 const prime = { XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1 };
+        size_t i;
+        for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {
+            /* xacc[i] ^= (xacc[i] >> 47); */
+            xxh_u64x2 const acc_vec  = xacc[i];
+            xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47);
+
+            /* xacc[i] ^= xsecret[i]; */
+            xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
+            xxh_u64x2 const data_key = data_vec ^ key_vec;
+
+            /* xacc[i] *= XXH_PRIME32_1 */
+            /* prod_lo = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)prime & 0xFFFFFFFF);  */
+            xxh_u64x2 const prod_even  = XXH_vec_mule((xxh_u32x4)data_key, prime);
+            /* prod_hi = ((xxh_u64x2)data_key >> 32) * ((xxh_u64x2)prime >> 32);  */
+            xxh_u64x2 const prod_odd  = XXH_vec_mulo((xxh_u32x4)data_key, prime);
+            xacc[i] = prod_odd + (prod_even << v32);
+    }   }
+}
+
+#endif
+
+/* scalar variants - universal */
+
+XXH_FORCE_INLINE void
+XXH3_accumulate_512_scalar(void* XXH_RESTRICT acc,
+                     const void* XXH_RESTRICT input,
+                     const void* XXH_RESTRICT secret)
+{
+    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */
+    const xxh_u8* const xinput  = (const xxh_u8*) input;  /* no alignment restriction */
+    const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */
+    size_t i;
+    XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);
+    for (i=0; i < XXH_ACC_NB; i++) {
+        xxh_u64 const data_val = XXH_readLE64(xinput + 8*i);
+        xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + i*8);
+        xacc[i ^ 1] += data_val; /* swap adjacent lanes */
+        xacc[i] += XXH_mult32to64(data_key & 0xFFFFFFFF, data_key >> 32);
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc;   /* presumed aligned */
+    const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */
+    size_t i;
+    XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0);
+    for (i=0; i < XXH_ACC_NB; i++) {
+        xxh_u64 const key64 = XXH_readLE64(xsecret + 8*i);
+        xxh_u64 acc64 = xacc[i];
+        acc64 = XXH_xorshift64(acc64, 47);
+        acc64 ^= key64;
+        acc64 *= XXH_PRIME32_1;
+        xacc[i] = acc64;
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
+{
+    /*
+     * We need a separate pointer for the hack below,
+     * which requires a non-const pointer.
+     * Any decent compiler will optimize this out otherwise.
+     */
+    const xxh_u8* kSecretPtr = XXH3_kSecret;
+    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);
+
+#if defined(__clang__) && defined(__aarch64__)
+    /*
+     * UGLY HACK:
+     * Clang generates a bunch of MOV/MOVK pairs for aarch64, and they are
+     * placed sequentially, in order, at the top of the unrolled loop.
+     *
+     * While MOVK is great for generating constants (2 cycles for a 64-bit
+     * constant compared to 4 cycles for LDR), long MOVK chains stall the
+     * integer pipelines:
+     *   I   L   S
+     * MOVK
+     * MOVK
+     * MOVK
+     * MOVK
+     * ADD
+     * SUB      STR
+     *          STR
+     * By forcing loads from memory (as the asm line causes Clang to assume
+     * that XXH3_kSecretPtr has been changed), the pipelines are used more
+     * efficiently:
+     *   I   L   S
+     *      LDR
+     *  ADD LDR
+     *  SUB     STR
+     *          STR
+     * XXH3_64bits_withSeed, len == 256, Snapdragon 835
+     *   without hack: 2654.4 MB/s
+     *   with hack:    3202.9 MB/s
+     */
+    __asm__("" : "+r" (kSecretPtr));
+#endif
+    /*
+     * Note: in debug mode, this overrides the asm optimization
+     * and Clang will emit MOVK chains again.
+     */
+    XXH_ASSERT(kSecretPtr == XXH3_kSecret);
+
+    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16;
+        int i;
+        for (i=0; i < nbRounds; i++) {
+            /*
+             * The asm hack causes Clang to assume that kSecretPtr aliases with
+             * customSecret, and on aarch64, this prevented LDP from merging two
+             * loads together for free. Putting the loads together before the stores
+             * properly generates LDP.
+             */
+            xxh_u64 lo = XXH_readLE64(kSecretPtr + 16*i)     + seed64;
+            xxh_u64 hi = XXH_readLE64(kSecretPtr + 16*i + 8) - seed64;
+            XXH_writeLE64((xxh_u8*)customSecret + 16*i,     lo);
+            XXH_writeLE64((xxh_u8*)customSecret + 16*i + 8, hi);
+    }   }
+}
+
+
+typedef void (*XXH3_f_accumulate_512)(void* XXH_RESTRICT, const void*, const void*);
+typedef void (*XXH3_f_scrambleAcc)(void* XXH_RESTRICT, const void*);
+typedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64);
+
+
+#if (XXH_VECTOR == XXH_AVX512)
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_avx512
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_avx512
+#define XXH3_initCustomSecret XXH3_initCustomSecret_avx512
+
+#elif (XXH_VECTOR == XXH_AVX2)
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_avx2
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_avx2
+#define XXH3_initCustomSecret XXH3_initCustomSecret_avx2
+
+#elif (XXH_VECTOR == XXH_SSE2)
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_sse2
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_sse2
+#define XXH3_initCustomSecret XXH3_initCustomSecret_sse2
+
+#elif (XXH_VECTOR == XXH_NEON)
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_neon
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_neon
+#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
+
+#elif (XXH_VECTOR == XXH_VSX)
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_vsx
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_vsx
+#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
+
+#else /* scalar */
+
+#define XXH3_accumulate_512 XXH3_accumulate_512_scalar
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_scalar
+#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
+
+#endif
+
+
+
+#ifndef XXH_PREFETCH_DIST
+#  ifdef __clang__
+#    define XXH_PREFETCH_DIST 320
+#  else
+#    if (XXH_VECTOR == XXH_AVX512)
+#      define XXH_PREFETCH_DIST 512
+#    else
+#      define XXH_PREFETCH_DIST 384
+#    endif
+#  endif  /* __clang__ */
+#endif  /* XXH_PREFETCH_DIST */
+
+/*
+ * XXH3_accumulate()
+ * Loops over XXH3_accumulate_512().
+ * Assumption: nbStripes will not overflow the secret size
+ */
+XXH_FORCE_INLINE void
+XXH3_accumulate(     xxh_u64* XXH_RESTRICT acc,
+                const xxh_u8* XXH_RESTRICT input,
+                const xxh_u8* XXH_RESTRICT secret,
+                      size_t nbStripes,
+                      XXH3_f_accumulate_512 f_acc512)
+{
+    size_t n;
+    for (n = 0; n < nbStripes; n++ ) {
+        const xxh_u8* const in = input + n*XXH_STRIPE_LEN;
+        XXH_PREFETCH(in + XXH_PREFETCH_DIST);
+        f_acc512(acc,
+                 in,
+                 secret + n*XXH_SECRET_CONSUME_RATE);
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,
+                      const xxh_u8* XXH_RESTRICT input, size_t len,
+                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                            XXH3_f_accumulate_512 f_acc512,
+                            XXH3_f_scrambleAcc f_scramble)
+{
+    size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;
+    size_t const block_len = XXH_STRIPE_LEN * nbStripesPerBlock;
+    size_t const nb_blocks = (len - 1) / block_len;
+
+    size_t n;
+
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
+
+    for (n = 0; n < nb_blocks; n++) {
+        XXH3_accumulate(acc, input + n*block_len, secret, nbStripesPerBlock, f_acc512);
+        f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN);
+    }
+
+    /* last partial block */
+    XXH_ASSERT(len > XXH_STRIPE_LEN);
+    {   size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN;
+        XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE));
+        XXH3_accumulate(acc, input + nb_blocks*block_len, secret, nbStripes, f_acc512);
+
+        /* last stripe */
+        {   const xxh_u8* const p = input + len - XXH_STRIPE_LEN;
+#define XXH_SECRET_LASTACC_START 7  /* not aligned on 8, last secret is different from acc & scrambler */
+            f_acc512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);
+    }   }
+}
+
+XXH_FORCE_INLINE xxh_u64
+XXH3_mix2Accs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret)
+{
+    return XXH3_mul128_fold64(
+               acc[0] ^ XXH_readLE64(secret),
+               acc[1] ^ XXH_readLE64(secret+8) );
+}
+
+static XXH64_hash_t
+XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 start)
+{
+    xxh_u64 result64 = start;
+    size_t i = 0;
+
+    for (i = 0; i < 4; i++) {
+        result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i);
+#if defined(__clang__)                                /* Clang */ \
+    && (defined(__arm__) || defined(__thumb__))       /* ARMv7 */ \
+    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */  \
+    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */
+        /*
+         * UGLY HACK:
+         * Prevent autovectorization on Clang ARMv7-a. Exact same problem as
+         * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b.
+         * XXH3_64bits, len == 256, Snapdragon 835:
+         *   without hack: 2063.7 MB/s
+         *   with hack:    2560.7 MB/s
+         */
+        __asm__("" : "+r" (result64));
+#endif
+    }
+
+    return XXH3_avalanche(result64);
+}
+
+#define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \
+                        XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 }
+
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,
+                           const void* XXH_RESTRICT secret, size_t secretSize,
+                           XXH3_f_accumulate_512 f_acc512,
+                           XXH3_f_scrambleAcc f_scramble)
+{
+    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;
+
+    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc512, f_scramble);
+
+    /* converge into final hash */
+    XXH_STATIC_ASSERT(sizeof(acc) == 64);
+    /* do not align on 8, so that the secret is different from the accumulator */
+#define XXH_SECRET_MERGEACCS_START 11
+    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
+    return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1);
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ */
+XXH_NO_INLINE XXH64_hash_t
+XXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len,
+                             XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)
+{
+    (void)seed64;
+    return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ * Since the function is not inlined, the compiler may not be able to understand that,
+ * in some scenarios, its `secret` argument is actually a compile time constant.
+ * This variant enforces that the compiler can detect that,
+ * and uses this opportunity to streamline the generated code for better performance.
+ */
+XXH_NO_INLINE XXH64_hash_t
+XXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len,
+                          XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)
+{
+    (void)seed64; (void)secret; (void)secretLen;
+    return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+/*
+ * XXH3_hashLong_64b_withSeed():
+ * Generate a custom key based on alteration of default XXH3_kSecret with the seed,
+ * and then use this key for long mode hashing.
+ *
+ * This operation is decently fast but nonetheless costs a little bit of time.
+ * Try to avoid it whenever possible (typically when seed==0).
+ *
+ * It's important for performance that XXH3_hashLong is not inlined. Not sure
+ * why (uop cache maybe?), but the difference is large and easily measurable.
+ */
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,
+                                    XXH64_hash_t seed,
+                                    XXH3_f_accumulate_512 f_acc512,
+                                    XXH3_f_scrambleAcc f_scramble,
+                                    XXH3_f_initCustomSecret f_initSec)
+{
+    if (seed == 0)
+        return XXH3_hashLong_64b_internal(input, len,
+                                          XXH3_kSecret, sizeof(XXH3_kSecret),
+                                          f_acc512, f_scramble);
+    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
+        f_initSec(secret, seed);
+        return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret),
+                                          f_acc512, f_scramble);
+    }
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ */
+XXH_NO_INLINE XXH64_hash_t
+XXH3_hashLong_64b_withSeed(const void* input, size_t len,
+                           XXH64_hash_t seed, const xxh_u8* secret, size_t secretLen)
+{
+    (void)secret; (void)secretLen;
+    return XXH3_hashLong_64b_withSeed_internal(input, len, seed,
+                XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret);
+}
+
+
+typedef XXH64_hash_t (*XXH3_hashLong64_f)(const void* XXH_RESTRICT, size_t,
+                                          XXH64_hash_t, const xxh_u8* XXH_RESTRICT, size_t);
+
+XXH_FORCE_INLINE XXH64_hash_t
+XXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,
+                     XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,
+                     XXH3_hashLong64_f f_hashLong)
+{
+    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
+    /*
+     * If an action is to be taken if `secretLen` condition is not respected,
+     * it should be done here.
+     * For now, it's a contract pre-condition.
+     * Adding a check and a branch here would cost performance at every hash.
+     * Also, note that function signature doesn't offer room to return an error.
+     */
+    if (len <= 16)
+        return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);
+    if (len <= 128)
+        return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
+    if (len <= XXH3_MIDSIZE_MAX)
+        return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
+    return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen);
+}
+
+
+/* ===   Public entry point   === */
+
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* input, size_t len)
+{
+    return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default);
+}
+
+XXH_PUBLIC_API XXH64_hash_t
+XXH3_64bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize)
+{
+    return XXH3_64bits_internal(input, len, 0, secret, secretSize, XXH3_hashLong_64b_withSecret);
+}
+
+XXH_PUBLIC_API XXH64_hash_t
+XXH3_64bits_withSeed(const void* input, size_t len, XXH64_hash_t seed)
+{
+    return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed);
+}
+
+
+/* ===   XXH3 streaming   === */
+
+/*
+ * Malloc's a pointer that is always aligned to align.
+ *
+ * This must be freed with `XXH_alignedFree()`.
+ *
+ * malloc typically guarantees 16 byte alignment on 64-bit systems and 8 byte
+ * alignment on 32-bit. This isn't enough for the 32 byte aligned loads in AVX2
+ * or on 32-bit, the 16 byte aligned loads in SSE2 and NEON.
+ *
+ * This underalignment previously caused a rather obvious crash which went
+ * completely unnoticed due to XXH3_createState() not actually being tested.
+ * Credit to RedSpah for noticing this bug.
+ *
+ * The alignment is done manually: Functions like posix_memalign or _mm_malloc
+ * are avoided: To maintain portability, we would have to write a fallback
+ * like this anyways, and besides, testing for the existence of library
+ * functions without relying on external build tools is impossible.
+ *
+ * The method is simple: Overallocate, manually align, and store the offset
+ * to the original behind the returned pointer.
+ *
+ * Align must be a power of 2 and 8 <= align <= 128.
+ */
+static void* XXH_alignedMalloc(size_t s, size_t align)
+{
+    XXH_ASSERT(align <= 128 && align >= 8); /* range check */
+    XXH_ASSERT((align & (align-1)) == 0);   /* power of 2 */
+    XXH_ASSERT(s != 0 && s < (s + align));  /* empty/overflow */
+    {   /* Overallocate to make room for manual realignment and an offset byte */
+        xxh_u8* base = (xxh_u8*)XXH_malloc(s + align);
+        if (base != NULL) {
+            /*
+             * Get the offset needed to align this pointer.
+             *
+             * Even if the returned pointer is aligned, there will always be
+             * at least one byte to store the offset to the original pointer.
+             */
+            size_t offset = align - ((size_t)base & (align - 1)); /* base % align */
+            /* Add the offset for the now-aligned pointer */
+            xxh_u8* ptr = base + offset;
+
+            XXH_ASSERT((size_t)ptr % align == 0);
+
+            /* Store the offset immediately before the returned pointer. */
+            ptr[-1] = (xxh_u8)offset;
+            return ptr;
+        }
+        return NULL;
+    }
+}
+/*
+ * Frees an aligned pointer allocated by XXH_alignedMalloc(). Don't pass
+ * normal malloc'd pointers, XXH_alignedMalloc has a specific data layout.
+ */
+static void XXH_alignedFree(void* p)
+{
+    if (p != NULL) {
+        xxh_u8* ptr = (xxh_u8*)p;
+        /* Get the offset byte we added in XXH_malloc. */
+        xxh_u8 offset = ptr[-1];
+        /* Free the original malloc'd pointer */
+        xxh_u8* base = ptr - offset;
+        XXH_free(base);
+    }
+}
+XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
+{
+    XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64);
+    if (state==NULL) return NULL;
+    XXH3_INITSTATE(state);
+    return state;
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)
+{
+    XXH_alignedFree(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API void
+XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state)
+{
+    memcpy(dst_state, src_state, sizeof(*dst_state));
+}
+
+static void
+XXH3_64bits_reset_internal(XXH3_state_t* statePtr,
+                           XXH64_hash_t seed,
+                           const void* secret, size_t secretSize)
+{
+    size_t const initStart = offsetof(XXH3_state_t, bufferedSize);
+    size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;
+    XXH_ASSERT(offsetof(XXH3_state_t, nbStripesPerBlock) > initStart);
+    XXH_ASSERT(statePtr != NULL);
+    /* set members from bufferedSize to nbStripesPerBlock (excluded) to 0 */
+    memset((char*)statePtr + initStart, 0, initLength);
+    statePtr->acc[0] = XXH_PRIME32_3;
+    statePtr->acc[1] = XXH_PRIME64_1;
+    statePtr->acc[2] = XXH_PRIME64_2;
+    statePtr->acc[3] = XXH_PRIME64_3;
+    statePtr->acc[4] = XXH_PRIME64_4;
+    statePtr->acc[5] = XXH_PRIME32_2;
+    statePtr->acc[6] = XXH_PRIME64_5;
+    statePtr->acc[7] = XXH_PRIME32_1;
+    statePtr->seed = seed;
+    statePtr->extSecret = (const unsigned char*)secret;
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
+    statePtr->secretLimit = secretSize - XXH_STRIPE_LEN;
+    statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_64bits_reset(XXH3_state_t* statePtr)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    XXH3_64bits_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    XXH3_64bits_reset_internal(statePtr, 0, secret, secretSize);
+    if (secret == NULL) return XXH_ERROR;
+    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    if (seed==0) return XXH3_64bits_reset(statePtr);
+    if (seed != statePtr->seed) XXH3_initCustomSecret(statePtr->customSecret, seed);
+    XXH3_64bits_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE);
+    return XXH_OK;
+}
+
+/* Note : when XXH3_consumeStripes() is invoked,
+ * there must be a guarantee that at least one more byte must be consumed from input
+ * so that the function can blindly consume all stripes using the "normal" secret segment */
+XXH_FORCE_INLINE void
+XXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc,
+                    size_t* XXH_RESTRICT nbStripesSoFarPtr, size_t nbStripesPerBlock,
+                    const xxh_u8* XXH_RESTRICT input, size_t nbStripes,
+                    const xxh_u8* XXH_RESTRICT secret, size_t secretLimit,
+                    XXH3_f_accumulate_512 f_acc512,
+                    XXH3_f_scrambleAcc f_scramble)
+{
+    XXH_ASSERT(nbStripes <= nbStripesPerBlock);  /* can handle max 1 scramble per invocation */
+    XXH_ASSERT(*nbStripesSoFarPtr < nbStripesPerBlock);
+    if (nbStripesPerBlock - *nbStripesSoFarPtr <= nbStripes) {
+        /* need a scrambling operation */
+        size_t const nbStripesToEndofBlock = nbStripesPerBlock - *nbStripesSoFarPtr;
+        size_t const nbStripesAfterBlock = nbStripes - nbStripesToEndofBlock;
+        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripesToEndofBlock, f_acc512);
+        f_scramble(acc, secret + secretLimit);
+        XXH3_accumulate(acc, input + nbStripesToEndofBlock * XXH_STRIPE_LEN, secret, nbStripesAfterBlock, f_acc512);
+        *nbStripesSoFarPtr = nbStripesAfterBlock;
+    } else {
+        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripes, f_acc512);
+        *nbStripesSoFarPtr += nbStripes;
+    }
+}
+
+/*
+ * Both XXH3_64bits_update and XXH3_128bits_update use this routine.
+ */
+XXH_FORCE_INLINE XXH_errorcode
+XXH3_update(XXH3_state_t* state,
+            const xxh_u8* input, size_t len,
+            XXH3_f_accumulate_512 f_acc512,
+            XXH3_f_scrambleAcc f_scramble)
+{
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
+#endif
+
+    {   const xxh_u8* const bEnd = input + len;
+        const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
+
+        state->totalLen += len;
+
+        if (state->bufferedSize + len <= XXH3_INTERNALBUFFER_SIZE) {  /* fill in tmp buffer */
+            XXH_memcpy(state->buffer + state->bufferedSize, input, len);
+            state->bufferedSize += (XXH32_hash_t)len;
+            return XXH_OK;
+        }
+        /* total input is now > XXH3_INTERNALBUFFER_SIZE */
+
+        #define XXH3_INTERNALBUFFER_STRIPES (XXH3_INTERNALBUFFER_SIZE / XXH_STRIPE_LEN)
+        XXH_STATIC_ASSERT(XXH3_INTERNALBUFFER_SIZE % XXH_STRIPE_LEN == 0);   /* clean multiple */
+
+        /*
+         * Internal buffer is partially filled (always, except at beginning)
+         * Complete it, then consume it.
+         */
+        if (state->bufferedSize) {
+            size_t const loadSize = XXH3_INTERNALBUFFER_SIZE - state->bufferedSize;
+            XXH_memcpy(state->buffer + state->bufferedSize, input, loadSize);
+            input += loadSize;
+            XXH3_consumeStripes(state->acc,
+                               &state->nbStripesSoFar, state->nbStripesPerBlock,
+                                state->buffer, XXH3_INTERNALBUFFER_STRIPES,
+                                secret, state->secretLimit,
+                                f_acc512, f_scramble);
+            state->bufferedSize = 0;
+        }
+        XXH_ASSERT(input < bEnd);
+
+        /* Consume input by a multiple of internal buffer size */
+        if (input+XXH3_INTERNALBUFFER_SIZE < bEnd) {
+            const xxh_u8* const limit = bEnd - XXH3_INTERNALBUFFER_SIZE;
+            do {
+                XXH3_consumeStripes(state->acc,
+                                   &state->nbStripesSoFar, state->nbStripesPerBlock,
+                                    input, XXH3_INTERNALBUFFER_STRIPES,
+                                    secret, state->secretLimit,
+                                    f_acc512, f_scramble);
+                input += XXH3_INTERNALBUFFER_SIZE;
+            } while (input<limit);
+            /* for last partial stripe */
+            memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);
+        }
+        XXH_ASSERT(input < bEnd);
+
+        /* Some remaining input (always) : buffer it */
+        XXH_memcpy(state->buffer, input, (size_t)(bEnd-input));
+        state->bufferedSize = (XXH32_hash_t)(bEnd-input);
+    }
+
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_64bits_update(XXH3_state_t* state, const void* input, size_t len)
+{
+    return XXH3_update(state, (const xxh_u8*)input, len,
+                       XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+
+XXH_FORCE_INLINE void
+XXH3_digest_long (XXH64_hash_t* acc,
+                  const XXH3_state_t* state,
+                  const unsigned char* secret)
+{
+    /*
+     * Digest on a local copy. This way, the state remains unaltered, and it can
+     * continue ingesting more input afterwards.
+     */
+    memcpy(acc, state->acc, sizeof(state->acc));
+    if (state->bufferedSize >= XXH_STRIPE_LEN) {
+        size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN;
+        size_t nbStripesSoFar = state->nbStripesSoFar;
+        XXH3_consumeStripes(acc,
+                           &nbStripesSoFar, state->nbStripesPerBlock,
+                            state->buffer, nbStripes,
+                            secret, state->secretLimit,
+                            XXH3_accumulate_512, XXH3_scrambleAcc);
+        /* last stripe */
+        XXH3_accumulate_512(acc,
+                            state->buffer + state->bufferedSize - XXH_STRIPE_LEN,
+                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
+    } else {  /* bufferedSize < XXH_STRIPE_LEN */
+        xxh_u8 lastStripe[XXH_STRIPE_LEN];
+        size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize;
+        XXH_ASSERT(state->bufferedSize > 0);  /* there is always some input buffered */
+        memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);
+        memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);
+        XXH3_accumulate_512(acc,
+                            lastStripe,
+                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
+    }
+}
+
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
+{
+    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
+    if (state->totalLen > XXH3_MIDSIZE_MAX) {
+        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
+        XXH3_digest_long(acc, state, secret);
+        return XXH3_mergeAccs(acc,
+                              secret + XXH_SECRET_MERGEACCS_START,
+                              (xxh_u64)state->totalLen * XXH_PRIME64_1);
+    }
+    /* totalLen <= XXH3_MIDSIZE_MAX: digesting a short input */
+    if (state->seed)
+        return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
+    return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen),
+                                  secret, state->secretLimit + XXH_STRIPE_LEN);
+}
+
+
+#define XXH_MIN(x, y) (((x) > (y)) ? (y) : (x))
+
+XXH_PUBLIC_API void
+XXH3_generateSecret(void* secretBuffer, const void* customSeed, size_t customSeedSize)
+{
+    XXH_ASSERT(secretBuffer != NULL);
+    if (customSeedSize == 0) {
+        memcpy(secretBuffer, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);
+        return;
+    }
+    XXH_ASSERT(customSeed != NULL);
+
+    {   size_t const segmentSize = sizeof(XXH128_hash_t);
+        size_t const nbSegments = XXH_SECRET_DEFAULT_SIZE / segmentSize;
+        XXH128_canonical_t scrambler;
+        XXH64_hash_t seeds[12];
+        size_t segnb;
+        XXH_ASSERT(nbSegments == 12);
+        XXH_ASSERT(segmentSize * nbSegments == XXH_SECRET_DEFAULT_SIZE); /* exact multiple */
+        XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0));
+
+        /*
+        * Copy customSeed to seeds[], truncating or repeating as necessary.
+        */
+        {   size_t toFill = XXH_MIN(customSeedSize, sizeof(seeds));
+            size_t filled = toFill;
+            memcpy(seeds, customSeed, toFill);
+            while (filled < sizeof(seeds)) {
+                toFill = XXH_MIN(filled, sizeof(seeds) - filled);
+                memcpy((char*)seeds + filled, seeds, toFill);
+                filled += toFill;
+        }   }
+
+        /* generate secret */
+        memcpy(secretBuffer, &scrambler, sizeof(scrambler));
+        for (segnb=1; segnb < nbSegments; segnb++) {
+            size_t const segmentStart = segnb * segmentSize;
+            XXH128_canonical_t segment;
+            XXH128_canonicalFromHash(&segment,
+                XXH128(&scrambler, sizeof(scrambler), XXH_readLE64(seeds + segnb) + segnb) );
+            memcpy((char*)secretBuffer + segmentStart, &segment, sizeof(segment));
+    }   }
+}
+
+
+/* ==========================================
+ * XXH3 128 bits (a.k.a XXH128)
+ * ==========================================
+ * XXH3's 128-bit variant has better mixing and strength than the 64-bit variant,
+ * even without counting the significantly larger output size.
+ *
+ * For example, extra steps are taken to avoid the seed-dependent collisions
+ * in 17-240 byte inputs (See XXH3_mix16B and XXH128_mix32B).
+ *
+ * This strength naturally comes at the cost of some speed, especially on short
+ * lengths. Note that longer hashes are about as fast as the 64-bit version
+ * due to it using only a slight modification of the 64-bit loop.
+ *
+ * XXH128 is also more oriented towards 64-bit machines. It is still extremely
+ * fast for a _128-bit_ hash on 32-bit (it usually clears XXH64).
+ */
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    /* A doubled version of 1to3_64b with different constants. */
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(1 <= len && len <= 3);
+    XXH_ASSERT(secret != NULL);
+    /*
+     * len = 1: combinedl = { input[0], 0x01, input[0], input[0] }
+     * len = 2: combinedl = { input[1], 0x02, input[0], input[1] }
+     * len = 3: combinedl = { input[2], 0x03, input[0], input[1] }
+     */
+    {   xxh_u8 const c1 = input[0];
+        xxh_u8 const c2 = input[len >> 1];
+        xxh_u8 const c3 = input[len - 1];
+        xxh_u32 const combinedl = ((xxh_u32)c1 <<16) | ((xxh_u32)c2 << 24)
+                                | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8);
+        xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);
+        xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
+        xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed;
+        xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl;
+        xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph;
+        XXH128_hash_t h128;
+        h128.low64  = XXH64_avalanche(keyed_lo);
+        h128.high64 = XXH64_avalanche(keyed_hi);
+        return h128;
+    }
+}
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(secret != NULL);
+    XXH_ASSERT(4 <= len && len <= 8);
+    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
+    {   xxh_u32 const input_lo = XXH_readLE32(input);
+        xxh_u32 const input_hi = XXH_readLE32(input + len - 4);
+        xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32);
+        xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed;
+        xxh_u64 const keyed = input_64 ^ bitflip;
+
+        /* Shift len to the left to ensure it is even, this avoids even multiplies. */
+        XXH128_hash_t m128 = XXH_mult64to128(keyed, XXH_PRIME64_1 + (len << 2));
+
+        m128.high64 += (m128.low64 << 1);
+        m128.low64  ^= (m128.high64 >> 3);
+
+        m128.low64   = XXH_xorshift64(m128.low64, 35);
+        m128.low64  *= 0x9FB21C651E98DF25ULL;
+        m128.low64   = XXH_xorshift64(m128.low64, 28);
+        m128.high64  = XXH3_avalanche(m128.high64);
+        return m128;
+    }
+}
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(input != NULL);
+    XXH_ASSERT(secret != NULL);
+    XXH_ASSERT(9 <= len && len <= 16);
+    {   xxh_u64 const bitflipl = (XXH_readLE64(secret+32) ^ XXH_readLE64(secret+40)) - seed;
+        xxh_u64 const bitfliph = (XXH_readLE64(secret+48) ^ XXH_readLE64(secret+56)) + seed;
+        xxh_u64 const input_lo = XXH_readLE64(input);
+        xxh_u64       input_hi = XXH_readLE64(input + len - 8);
+        XXH128_hash_t m128 = XXH_mult64to128(input_lo ^ input_hi ^ bitflipl, XXH_PRIME64_1);
+        /*
+         * Put len in the middle of m128 to ensure that the length gets mixed to
+         * both the low and high bits in the 128x64 multiply below.
+         */
+        m128.low64 += (xxh_u64)(len - 1) << 54;
+        input_hi   ^= bitfliph;
+        /*
+         * Add the high 32 bits of input_hi to the high 32 bits of m128, then
+         * add the long product of the low 32 bits of input_hi and XXH_PRIME32_2 to
+         * the high 64 bits of m128.
+         *
+         * The best approach to this operation is different on 32-bit and 64-bit.
+         */
+        if (sizeof(void *) < sizeof(xxh_u64)) { /* 32-bit */
+            /*
+             * 32-bit optimized version, which is more readable.
+             *
+             * On 32-bit, it removes an ADC and delays a dependency between the two
+             * halves of m128.high64, but it generates an extra mask on 64-bit.
+             */
+            m128.high64 += (input_hi & 0xFFFFFFFF00000000ULL) + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2);
+        } else {
+            /*
+             * 64-bit optimized (albeit more confusing) version.
+             *
+             * Uses some properties of addition and multiplication to remove the mask:
+             *
+             * Let:
+             *    a = input_hi.lo = (input_hi & 0x00000000FFFFFFFF)
+             *    b = input_hi.hi = (input_hi & 0xFFFFFFFF00000000)
+             *    c = XXH_PRIME32_2
+             *
+             *    a + (b * c)
+             * Inverse Property: x + y - x == y
+             *    a + (b * (1 + c - 1))
+             * Distributive Property: x * (y + z) == (x * y) + (x * z)
+             *    a + (b * 1) + (b * (c - 1))
+             * Identity Property: x * 1 == x
+             *    a + b + (b * (c - 1))
+             *
+             * Substitute a, b, and c:
+             *    input_hi.hi + input_hi.lo + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))
+             *
+             * Since input_hi.hi + input_hi.lo == input_hi, we get this:
+             *    input_hi + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))
+             */
+            m128.high64 += input_hi + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2 - 1);
+        }
+        /* m128 ^= XXH_swap64(m128 >> 64); */
+        m128.low64  ^= XXH_swap64(m128.high64);
+
+        {   /* 128x64 multiply: h128 = m128 * XXH_PRIME64_2; */
+            XXH128_hash_t h128 = XXH_mult64to128(m128.low64, XXH_PRIME64_2);
+            h128.high64 += m128.high64 * XXH_PRIME64_2;
+
+            h128.low64   = XXH3_avalanche(h128.low64);
+            h128.high64  = XXH3_avalanche(h128.high64);
+            return h128;
+    }   }
+}
+
+/*
+ * Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN
+ */
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
+{
+    XXH_ASSERT(len <= 16);
+    {   if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed);
+        if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed);
+        if (len) return XXH3_len_1to3_128b(input, len, secret, seed);
+        {   XXH128_hash_t h128;
+            xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72);
+            xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88);
+            h128.low64 = XXH64_avalanche(seed ^ bitflipl);
+            h128.high64 = XXH64_avalanche( seed ^ bitfliph);
+            return h128;
+    }   }
+}
+
+/*
+ * A bit slower than XXH3_mix16B, but handles multiply by zero better.
+ */
+XXH_FORCE_INLINE XXH128_hash_t
+XXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,
+              const xxh_u8* secret, XXH64_hash_t seed)
+{
+    acc.low64  += XXH3_mix16B (input_1, secret+0, seed);
+    acc.low64  ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);
+    acc.high64 += XXH3_mix16B (input_2, secret+16, seed);
+    acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);
+    return acc;
+}
+
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
+                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                      XXH64_hash_t seed)
+{
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
+    XXH_ASSERT(16 < len && len <= 128);
+
+    {   XXH128_hash_t acc;
+        acc.low64 = len * XXH_PRIME64_1;
+        acc.high64 = 0;
+        if (len > 32) {
+            if (len > 64) {
+                if (len > 96) {
+                    acc = XXH128_mix32B(acc, input+48, input+len-64, secret+96, seed);
+                }
+                acc = XXH128_mix32B(acc, input+32, input+len-48, secret+64, seed);
+            }
+            acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed);
+        }
+        acc = XXH128_mix32B(acc, input, input+len-16, secret, seed);
+        {   XXH128_hash_t h128;
+            h128.low64  = acc.low64 + acc.high64;
+            h128.high64 = (acc.low64    * XXH_PRIME64_1)
+                        + (acc.high64   * XXH_PRIME64_4)
+                        + ((len - seed) * XXH_PRIME64_2);
+            h128.low64  = XXH3_avalanche(h128.low64);
+            h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);
+            return h128;
+        }
+    }
+}
+
+XXH_NO_INLINE XXH128_hash_t
+XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
+                       const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                       XXH64_hash_t seed)
+{
+    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
+    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
+
+    {   XXH128_hash_t acc;
+        int const nbRounds = (int)len / 32;
+        int i;
+        acc.low64 = len * XXH_PRIME64_1;
+        acc.high64 = 0;
+        for (i=0; i<4; i++) {
+            acc = XXH128_mix32B(acc,
+                                input  + (32 * i),
+                                input  + (32 * i) + 16,
+                                secret + (32 * i),
+                                seed);
+        }
+        acc.low64 = XXH3_avalanche(acc.low64);
+        acc.high64 = XXH3_avalanche(acc.high64);
+        XXH_ASSERT(nbRounds >= 4);
+        for (i=4 ; i < nbRounds; i++) {
+            acc = XXH128_mix32B(acc,
+                                input + (32 * i),
+                                input + (32 * i) + 16,
+                                secret + XXH3_MIDSIZE_STARTOFFSET + (32 * (i - 4)),
+                                seed);
+        }
+        /* last bytes */
+        acc = XXH128_mix32B(acc,
+                            input + len - 16,
+                            input + len - 32,
+                            secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16,
+                            0ULL - seed);
+
+        {   XXH128_hash_t h128;
+            h128.low64  = acc.low64 + acc.high64;
+            h128.high64 = (acc.low64    * XXH_PRIME64_1)
+                        + (acc.high64   * XXH_PRIME64_4)
+                        + ((len - seed) * XXH_PRIME64_2);
+            h128.low64  = XXH3_avalanche(h128.low64);
+            h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);
+            return h128;
+        }
+    }
+}
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,
+                            const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
+                            XXH3_f_accumulate_512 f_acc512,
+                            XXH3_f_scrambleAcc f_scramble)
+{
+    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;
+
+    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc512, f_scramble);
+
+    /* converge into final hash */
+    XXH_STATIC_ASSERT(sizeof(acc) == 64);
+    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
+    {   XXH128_hash_t h128;
+        h128.low64  = XXH3_mergeAccs(acc,
+                                     secret + XXH_SECRET_MERGEACCS_START,
+                                     (xxh_u64)len * XXH_PRIME64_1);
+        h128.high64 = XXH3_mergeAccs(acc,
+                                     secret + secretSize
+                                            - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
+                                     ~((xxh_u64)len * XXH_PRIME64_2));
+        return h128;
+    }
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ */
+XXH_NO_INLINE XXH128_hash_t
+XXH3_hashLong_128b_default(const void* XXH_RESTRICT input, size_t len,
+                           XXH64_hash_t seed64,
+                           const void* XXH_RESTRICT secret, size_t secretLen)
+{
+    (void)seed64; (void)secret; (void)secretLen;
+    return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret),
+                                       XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ */
+XXH_NO_INLINE XXH128_hash_t
+XXH3_hashLong_128b_withSecret(const void* XXH_RESTRICT input, size_t len,
+                              XXH64_hash_t seed64,
+                              const void* XXH_RESTRICT secret, size_t secretLen)
+{
+    (void)seed64;
+    return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, secretLen,
+                                       XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,
+                                XXH64_hash_t seed64,
+                                XXH3_f_accumulate_512 f_acc512,
+                                XXH3_f_scrambleAcc f_scramble,
+                                XXH3_f_initCustomSecret f_initSec)
+{
+    if (seed64 == 0)
+        return XXH3_hashLong_128b_internal(input, len,
+                                           XXH3_kSecret, sizeof(XXH3_kSecret),
+                                           f_acc512, f_scramble);
+    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
+        f_initSec(secret, seed64);
+        return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),
+                                           f_acc512, f_scramble);
+    }
+}
+
+/*
+ * It's important for performance that XXH3_hashLong is not inlined.
+ */
+XXH_NO_INLINE XXH128_hash_t
+XXH3_hashLong_128b_withSeed(const void* input, size_t len,
+                            XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen)
+{
+    (void)secret; (void)secretLen;
+    return XXH3_hashLong_128b_withSeed_internal(input, len, seed64,
+                XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret);
+}
+
+typedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, size_t,
+                                            XXH64_hash_t, const void* XXH_RESTRICT, size_t);
+
+XXH_FORCE_INLINE XXH128_hash_t
+XXH3_128bits_internal(const void* input, size_t len,
+                      XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,
+                      XXH3_hashLong128_f f_hl128)
+{
+    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);
+    /*
+     * If an action is to be taken if `secret` conditions are not respected,
+     * it should be done here.
+     * For now, it's a contract pre-condition.
+     * Adding a check and a branch here would cost performance at every hash.
+     */
+    if (len <= 16)
+        return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);
+    if (len <= 128)
+        return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
+    if (len <= XXH3_MIDSIZE_MAX)
+        return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);
+    return f_hl128(input, len, seed64, secret, secretLen);
+}
+
+
+/* ===   Public XXH128 API   === */
+
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* input, size_t len)
+{
+    return XXH3_128bits_internal(input, len, 0,
+                                 XXH3_kSecret, sizeof(XXH3_kSecret),
+                                 XXH3_hashLong_128b_default);
+}
+
+XXH_PUBLIC_API XXH128_hash_t
+XXH3_128bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize)
+{
+    return XXH3_128bits_internal(input, len, 0,
+                                 (const xxh_u8*)secret, secretSize,
+                                 XXH3_hashLong_128b_withSecret);
+}
+
+XXH_PUBLIC_API XXH128_hash_t
+XXH3_128bits_withSeed(const void* input, size_t len, XXH64_hash_t seed)
+{
+    return XXH3_128bits_internal(input, len, seed,
+                                 XXH3_kSecret, sizeof(XXH3_kSecret),
+                                 XXH3_hashLong_128b_withSeed);
+}
+
+XXH_PUBLIC_API XXH128_hash_t
+XXH128(const void* input, size_t len, XXH64_hash_t seed)
+{
+    return XXH3_128bits_withSeed(input, len, seed);
+}
+
+
+/* ===   XXH3 128-bit streaming   === */
+
+/*
+ * All the functions are actually the same as for 64-bit streaming variant.
+ * The only difference is the finalizatiom routine.
+ */
+
+static void
+XXH3_128bits_reset_internal(XXH3_state_t* statePtr,
+                            XXH64_hash_t seed,
+                            const void* secret, size_t secretSize)
+{
+    XXH3_64bits_reset_internal(statePtr, seed, secret, secretSize);
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_128bits_reset(XXH3_state_t* statePtr)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    XXH3_128bits_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    XXH3_128bits_reset_internal(statePtr, 0, secret, secretSize);
+    if (secret == NULL) return XXH_ERROR;
+    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
+{
+    if (statePtr == NULL) return XXH_ERROR;
+    if (seed==0) return XXH3_128bits_reset(statePtr);
+    if (seed != statePtr->seed) XXH3_initCustomSecret(statePtr->customSecret, seed);
+    XXH3_128bits_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode
+XXH3_128bits_update(XXH3_state_t* state, const void* input, size_t len)
+{
+    return XXH3_update(state, (const xxh_u8*)input, len,
+                       XXH3_accumulate_512, XXH3_scrambleAcc);
+}
+
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* state)
+{
+    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
+    if (state->totalLen > XXH3_MIDSIZE_MAX) {
+        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
+        XXH3_digest_long(acc, state, secret);
+        XXH_ASSERT(state->secretLimit + XXH_STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
+        {   XXH128_hash_t h128;
+            h128.low64  = XXH3_mergeAccs(acc,
+                                         secret + XXH_SECRET_MERGEACCS_START,
+                                         (xxh_u64)state->totalLen * XXH_PRIME64_1);
+            h128.high64 = XXH3_mergeAccs(acc,
+                                         secret + state->secretLimit + XXH_STRIPE_LEN
+                                                - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
+                                         ~((xxh_u64)state->totalLen * XXH_PRIME64_2));
+            return h128;
+        }
+    }
+    /* len <= XXH3_MIDSIZE_MAX : short code */
+    if (state->seed)
+        return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
+    return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen),
+                                   secret, state->secretLimit + XXH_STRIPE_LEN);
+}
+
+/* 128-bit utility functions */
+
+#include <string.h>   /* memcmp, memcpy */
+
+/* return : 1 is equal, 0 if different */
+XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)
+{
+    /* note : XXH128_hash_t is compact, it has no padding byte */
+    return !(memcmp(&h1, &h2, sizeof(h1)));
+}
+
+/* This prototype is compatible with stdlib's qsort().
+ * return : >0 if *h128_1  > *h128_2
+ *          <0 if *h128_1  < *h128_2
+ *          =0 if *h128_1 == *h128_2  */
+XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2)
+{
+    XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;
+    XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;
+    int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64);
+    /* note : bets that, in most cases, hash values are different */
+    if (hcmp) return hcmp;
+    return (h1.low64 > h2.low64) - (h2.low64 > h1.low64);
+}
+
+
+/*======   Canonical representation   ======*/
+XXH_PUBLIC_API void
+XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) {
+        hash.high64 = XXH_swap64(hash.high64);
+        hash.low64  = XXH_swap64(hash.low64);
+    }
+    memcpy(dst, &hash.high64, sizeof(hash.high64));
+    memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
+}
+
+XXH_PUBLIC_API XXH128_hash_t
+XXH128_hashFromCanonical(const XXH128_canonical_t* src)
+{
+    XXH128_hash_t h;
+    h.high64 = XXH_readBE64(src);
+    h.low64  = XXH_readBE64(src->digest + 8);
+    return h;
+}
+
+/* Pop our optimization override from above */
+#if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \
+  && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
+  && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */
+#  pragma GCC pop_options
+#endif
+
+#endif  /* XXH_NO_LONG_LONG */
+
+
+#endif  /* XXH_IMPLEMENTATION */
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/include/hash/cc_lookup3.h b/include/rust/cc_log_rs.h
similarity index 80%
rename from include/hash/cc_lookup3.h
rename to include/rust/cc_log_rs.h
index af6f8318c..27c22dfb7 100644
--- a/include/hash/cc_lookup3.h
+++ b/include/rust/cc_log_rs.h
@@ -1,5 +1,4 @@
-/*
- * ccommon - a cache common library.
+/* ccommon - a cache common library.
  * Copyright (C) 2013 Twitter, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,10 +22,10 @@ extern "C" {
 
 #include <cc_define.h>
 
-#include <stdint.h>
-#include <stdlib.h>
+/* NOTE: for documentation see ccommon/rust/ccommon_rs/src/log/mod.rs */
 
-uint32_t hash_lookup3(const void *key, size_t length, const uint32_t initval);
+rstatus_i rust_log_setup(void);
+void rust_log_teardown(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/time/cc_timer.h b/include/time/cc_timer.h
index 6a8c382ee..86b871a7a 100644
--- a/include/time/cc_timer.h
+++ b/include/time/cc_timer.h
@@ -49,6 +49,14 @@ struct duration;  /* data structure to measure duration */
  *   relationship between this unit and nanosecond can be obtained via another
  *   syscall
  */
+
+enum duration_type {
+    DURATION_PRECISE, /* default */
+    DURATION_FAST,
+
+    MAX_DURATION_TYPE
+};
+
 #ifdef OS_DARWIN
 struct duration {
     bool        started;
@@ -58,6 +66,7 @@ struct duration {
 };
 #elif defined OS_LINUX
 struct duration {
+    enum duration_type type;
     bool            started;
     bool            stopped;
     struct timespec start;
@@ -86,12 +95,12 @@ struct timeout {
     bool        is_intvl;
 };
 
-
 /* update duration */
 void duration_reset(struct duration *d);
 /* get a reading of duration and copy it without stopping the original timer */
 void duration_snapshot(struct duration *s, const struct duration *d);
 void duration_start(struct duration *d);
+void duration_start_type(struct duration *d, enum duration_type type);
 void duration_stop(struct duration *d);
 /* read duration */
 double duration_ns(struct duration *d);
@@ -99,6 +108,18 @@ double duration_us(struct duration *d);
 double duration_ms(struct duration *d);
 double duration_sec(struct duration *d);
 
+static inline int
+duration_compare(const void *lhs, const void *rhs)
+{
+    double lns = duration_ns((struct duration *)lhs);
+    double rns = duration_ns((struct duration *)rhs);
+    if (lns < rns)
+        return -1;
+    if (lns > rns)
+        return 1;
+
+    return 0;
+}
 
 /*
  * Not all possible granularity can be meaningfully used for sleep or event.
diff --git a/rust/CMakeLists.txt b/rust/CMakeLists.txt
index 808fb4391..37f472807 100644
--- a/rust/CMakeLists.txt
+++ b/rust/CMakeLists.txt
@@ -1,5 +1,22 @@
 file(WRITE CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}\n")
 
+execute_process(
+    COMMAND /usr/bin/env "CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR}" "/bin/bash" "${CMAKE_CURRENT_LIST_DIR}/scripts/setup.sh"
+    WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}"
+    RESULT_VARIABLE CARGO_RESULT
+    OUTPUT_VARIABLE CARGO_CONFIG_OUT
+    ERROR_VARIABLE CARGO_CONFIG_OUT)
+
 if(HAVE_RUST)
-    add_subdirectory(ccommon_rs)
+    add_subdirectory(ccommon-array)
+    add_subdirectory(ccommon-backend)
+    add_subdirectory(ccommon-buffer)
+    add_subdirectory(ccommon-channel)
+    add_subdirectory(ccommon-derive)
+    add_subdirectory(ccommon-log)
+    add_subdirectory(ccommon-rs)
+    add_subdirectory(ccommon-stats)
+    add_subdirectory(ccommon-stream)
+    add_subdirectory(ccommon-sys)
+    
 endif()
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
deleted file mode 100644
index 5ae870301..000000000
--- a/rust/Cargo.lock
+++ /dev/null
@@ -1,496 +0,0 @@
-[[package]]
-name = "aho-corasick"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "backtrace"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "backtrace-sys 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)",
- "cfg-if 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-demangle 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "backtrace-sys"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cc 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bindgen"
-version = "0.37.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cexpr 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "cfg-if 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "clang-sys 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "env_logger 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "which 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "cc"
-version = "1.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "cc_binding"
-version = "0.1.0"
-dependencies = [
- "bindgen 0.37.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "ccommon_rs"
-version = "0.1.0"
-dependencies = [
- "cc_binding 0.1.0",
- "failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "cexpr"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "cfg-if"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "clang-sys"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "libloading 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "clap"
-version = "2.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "atty 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "atty 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "termcolor 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "failure"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "failure_derive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "failure_derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "synstructure 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "glob"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "humantime"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "libc"
-version = "0.2.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "libloading"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cc 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "log"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "cfg-if 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "memchr"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "memchr"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "nom"
-version = "3.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "peeking_take_while"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "proc-macro2"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "quick-error"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "quote"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "quote"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.1.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "redox_termios"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "aho-corasick 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "regex-syntax 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "strsim"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "syn"
-version = "0.11.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "synom"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "synstructure"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "termcolor"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "wincolor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "termion"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
- "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "textwrap"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "thread_local"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "ucd-util"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-xid"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unicode-xid"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "unreachable"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "utf8-ranges"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "vec_map"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "void"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "which"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "wincolor"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[metadata]
-"checksum aho-corasick 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f0ba20154ea1f47ce2793322f049c5646cc6d0fa9759d5f333f286e507bf8080"
-"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
-"checksum atty 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2fc4a1aa4c24c0718a250f0681885c1af91419d242f29eb8f2ab28502d80dbd1"
-"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
-"checksum backtrace-sys 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)" = "bff67d0c06556c0b8e6b5f090f0eac52d950d9dfd1d35ba04e4ca3543eaf6a7e"
-"checksum bindgen 0.37.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1b25ab82877ea8fe6ce1ce1f8ac54361f0218bad900af9eb11803994bf67c221"
-"checksum bitflags 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d0c54bb8f454c567f21197eefcdbf5679d0bd99f2ddbe52e84c77061952e6789"
-"checksum cc 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)" = "49ec142f5768efb5b7622aebc3fdbdbb8950a4b9ba996393cb76ef7466e8747d"
-"checksum cexpr 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "42aac45e9567d97474a834efdee3081b3c942b2205be932092f53354ce503d6c"
-"checksum cfg-if 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "efe5c877e17a9c717a0bf3613b2709f723202c4e4675cc8f12926ded29bcb17e"
-"checksum clang-sys 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d7f7c04e52c35222fffcc3a115b5daf5f7e2bfb71c13c4e2321afe1fc71859c2"
-"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
-"checksum env_logger 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)" = "0e6e40ebb0e66918a37b38c7acab4e10d299e0463fe2af5d29b9cc86710cfd2a"
-"checksum failure 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "934799b6c1de475a012a02dab0ace1ace43789ee4b99bcfbf1a2e3e8ced5de82"
-"checksum failure_derive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c7cdda555bb90c9bb67a3b670a0f42de8e73f5981524123ad8578aafec8ddb8b"
-"checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
-"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"
-"checksum lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e6412c5e2ad9584b0b8e979393122026cdd6d2a80b933f890dcd694ddbe73739"
-"checksum libc 0.2.42 (registry+https://github.com/rust-lang/crates.io-index)" = "b685088df2b950fccadf07a7187c8ef846a959c142338a48f9dc0b94517eb5f1"
-"checksum libloading 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3ad660d7cb8c5822cd83d10897b0f1f1526792737a179e73896152f85b88c2"
-"checksum log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "61bd98ae7f7b754bc53dca7d44b604f733c6bba044ea6f41bc8d89272d8161d2"
-"checksum memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "148fab2e51b4f1cfc66da2a7c32981d1d3c083a803978268bb11fe4b86925e7a"
-"checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
-"checksum nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05aec50c70fd288702bcd93284a8444607f3292dbdf2a30de5ea5dcdbe72287b"
-"checksum peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
-"checksum proc-macro2 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "77997c53ae6edd6d187fec07ec41b207063b5ee6f33680e9fa86d405cdd313d4"
-"checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
-"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
-"checksum quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8"
-"checksum redox_syscall 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "c214e91d3ecf43e9a4e41e578973adeb14b474f2bee858742d127af75a0112b1"
-"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
-"checksum regex 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "13c93d55961981ba9226a213b385216f83ab43bd6ac53ab16b2eeb47e337cf4e"
-"checksum regex-syntax 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05b06a75f5217880fc5e905952a42750bf44787e56a6c6d6852ed0992f5e1d54"
-"checksum rustc-demangle 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "76d7ba1feafada44f2d38eed812bd2489a03c0f5abb975799251518b68848649"
-"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
-"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
-"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
-"checksum synstructure 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3a761d12e6d8dcb4dcf952a7a89b475e3a9d69e4a69307e01a470977642914bd"
-"checksum termcolor 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "adc4587ead41bf016f11af03e55a624c06568b5a19db4e90fde573d805074f83"
-"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
-"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
-"checksum thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279ef31c19ededf577bfd12dfae728040a21f635b06a24cd670ff510edd38963"
-"checksum ucd-util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fd2be2d6639d0f8fe6cdda291ad456e23629558d466e2789d2c3e9892bda285d"
-"checksum unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526"
-"checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
-"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
-"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
-"checksum utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "662fab6525a98beff2921d7f61a39e7d59e0b425ebc7d0d9e66d316e55124122"
-"checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
-"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
-"checksum which 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e84a603e7e0b1ce1aa1ee2b109c7be00155ce52df5081590d1ffb93f4f515cb2"
-"checksum winapi 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "773ef9dcc5f24b7d850d0ff101e542ff24c3b090a9768e03ff889fdef41f00fd"
-"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-"checksum wincolor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "eeb06499a3a4d44302791052df005d5232b927ed1a9658146d842165c4de7767"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
deleted file mode 100644
index ae5821dad..000000000
--- a/rust/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[workspace]
-
-members = [
-    "cc_binding",
-    "ccommon_rs",
-]
-
-[profile.release]
-opt-level = 3
-debug = true
-rpath = false
-lto = true
-debug-assertions = false
-codegen-units = 1
-
-[profile.dev]
-debug = true
-opt-level = 0
-
-[term]
-verbose = true
diff --git a/rust/cc_binding/CMakeLists.txt b/rust/cc_binding/CMakeLists.txt
deleted file mode 100644
index 6c8be94ae..000000000
--- a/rust/cc_binding/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-cargo_build(NAME cc_binding)
-
-add_dependencies(cc_binding_static ccommon-static)
-add_dependencies(cc_binding_shared ccommon-shared)
diff --git a/rust/cc_binding/Cargo.toml b/rust/cc_binding/Cargo.toml
deleted file mode 100644
index 0ad06b1df..000000000
--- a/rust/cc_binding/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-name = "cc_binding"
-version = "0.1.0"
-authors = ["Jonathan Simms <jsimms@twitter.com>"]
-
-[build-dependencies]
-bindgen = "0.37.0"
-failure = "~0.1.1"
-
-[lib]
-name = "cc_binding"
-crate-type = ["rlib", "dylib", "staticlib", "lib"]
diff --git a/rust/cc_binding/build.rs b/rust/cc_binding/build.rs
deleted file mode 100644
index 4e6dc243d..000000000
--- a/rust/cc_binding/build.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-extern crate bindgen;
-#[macro_use]
-extern crate failure;
-
-use std::env;
-use std::fs;
-use std::io;
-use std::io::BufReader;
-use std::io::prelude::*;
-use std::ffi::OsString;
-use std::os::unix::fs as unix_fs;
-use std::path::Path;
-use std::path::PathBuf;
-use std::result;
-
-type Result<T> = result::Result<T, failure::Error>;
-
-fn get_cmake_binary_dir() -> io::Result<String> {
-    // this file is written by cmake on each run, updated with the location of
-    // the build directory.
-    let mut fp = fs::File::open("../CMAKE_BINARY_DIR")?;
-    let mut buf = String::new();
-    let n = fp.read_to_string(&mut buf)?;
-    assert!(n > 0, "file was empty");
-    Ok(String::from(buf.trim_right()))
-}
-
-const CMAKE_CACHE: &str = "CMakeCache.txt";
-const CCOMMON_BINARY_DIR_KEY: &str = "ccommon_BINARY_DIR:STATIC";
-
-fn get_cmake_cache_value(binary_dir: &Path, key: &str) -> Result<Option<String>> {
-    let cache_path = binary_dir.join(CMAKE_CACHE);
-    let fp = BufReader::new(fs::File::open(cache_path)?);
-
-    for x in fp.lines() {
-        let line = x?;
-        let needle = format!("{}=", key);
-        if line.starts_with(&needle[..]) {
-            if let Some(v) = line.rsplit("=").take(1).last() {
-                return Ok(Some(v.to_owned()))
-            } else {
-                bail!("bad line: {:#?}", line);
-            }
-        }
-    }
-
-    Ok(None)
-}
-
-fn main() {
-    println!("cargo:rustc-link-lib=static=ccommon-1.2.0");
-
-    let include_path = fs::canonicalize("./../../include").unwrap();
-
-    let cmake_binary_dir = match get_cmake_binary_dir() {
-        Ok(p) => p,
-        Err(err) => panic!("Failed locating the CMAKE_BINARY_DIR file: {:#?}", err),
-    };
-
-    let cbd = PathBuf::from(cmake_binary_dir);
-
-    let mut config_h_dir = cbd.clone();
-    config_h_dir.push("ccommon");
-
-    let lib_dir: String = {
-        let cbd = get_cmake_cache_value(&cbd, CCOMMON_BINARY_DIR_KEY)
-            .map(|o| o.map(OsString::from))
-            .unwrap()
-            .expect(
-                format!("could not find {} in {}", CCOMMON_BINARY_DIR_KEY, CMAKE_CACHE).as_ref()
-            );
-
-        let cbd = Path::new(&cbd);
-        cbd.join("lib").to_str().unwrap().to_string()
-    };
-
-    println!("cargo:rustc-link-search=native={}", lib_dir);
-
-    let bindings = bindgen::Builder::default()
-        .clang_args(vec![
-            "-I", include_path.to_str().unwrap(),
-            "-I", config_h_dir.to_str().unwrap(),
-            "-I", cbd.to_str().unwrap(),
-            "-L", &lib_dir,
-        ])
-        .header("wrapper.h")
-        .blacklist_type("max_align_t") // https://github.com/rust-lang-nursery/rust-bindgen/issues/550
-        .generate()
-        .expect("Unable to generate bindings");
-
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
-    bindings
-        .write_to_file(out_path.join("bindings.rs"))
-        .expect("Couldn't write bindings!");
-
-    // ./target/debug/build/cc_binding-27eac70f0fa2e180/out  <<- starts here
-
-    // cc_binding-27eac70f0fa2e180
-    let symlink_content =
-        out_path.parent().unwrap().file_name().unwrap();
-
-    let build_dir = out_path.parent().and_then(|p| p.parent()).unwrap();
-
-    let link_location = build_dir.join("cc_binding");
-    let _ = fs::remove_file(link_location.as_path());
-    unix_fs::symlink(symlink_content, link_location).unwrap();
-}
-
diff --git a/rust/cc_binding/src/lib.rs b/rust/cc_binding/src/lib.rs
deleted file mode 100644
index 2cf071191..000000000
--- a/rust/cc_binding/src/lib.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(unknown_lints)]
-#![allow(clippy)]
-#![allow(clippy_pedantic)]
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(dead_code)]
-include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
diff --git a/rust/cc_binding/wrapper.h b/rust/cc_binding/wrapper.h
deleted file mode 100644
index c5b21b148..000000000
--- a/rust/cc_binding/wrapper.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#include <cc_bstring.h>
-#include <buffer/cc_buf.h>
diff --git a/rust/ccommon-array/CMakeLists.txt b/rust/ccommon-array/CMakeLists.txt
new file mode 100644
index 000000000..5bdbec3ee
--- /dev/null
+++ b/rust/ccommon-array/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-array)
diff --git a/rust/ccommon-array/Cargo.toml b/rust/ccommon-array/Cargo.toml
new file mode 100644
index 000000000..fe3f66754
--- /dev/null
+++ b/rust/ccommon-array/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "ccommon-array"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
diff --git a/rust/ccommon-array/src/lib.rs b/rust/ccommon-array/src/lib.rs
new file mode 100644
index 000000000..772ab6675
--- /dev/null
+++ b/rust/ccommon-array/src/lib.rs
@@ -0,0 +1,38 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const NELEM_DELTA: usize = 16;
+
+// helper functions
+fn nelem_delta() -> usize {
+    NELEM_DELTA
+}
+
+// definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ArrayConfig {
+    #[cfg_attr(feature = "serde", serde(default = "nelem_delta"))]
+    nelem_delta: usize,
+}
+
+// implementation
+impl ArrayConfig {
+    pub fn nelem_delta(&self) -> usize {
+        self.nelem_delta
+    }
+}
+
+// trait implementations
+impl Default for ArrayConfig {
+    fn default() -> Self {
+        Self {
+            nelem_delta: nelem_delta(),
+        }
+    }
+}
diff --git a/rust/ccommon-backend/CMakeLists.txt b/rust/ccommon-backend/CMakeLists.txt
new file mode 100644
index 000000000..a29e51eb0
--- /dev/null
+++ b/rust/ccommon-backend/CMakeLists.txt
@@ -0,0 +1 @@
+cargo_build(NAME ccommon-backend)
diff --git a/rust/ccommon-backend/Cargo.toml b/rust/ccommon-backend/Cargo.toml
new file mode 100644
index 000000000..b4483ac43
--- /dev/null
+++ b/rust/ccommon-backend/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "ccommon-backend"
+version = "0.1.0"
+authors = ["Sean Lynch <slynch@twitter.com>"]
+edition = "2018"
+
+[features]
+c-export = []
+
+[dependencies]
+ccommon-sys = { path = "../ccommon-sys" }
+libc = "0.2"
+
+# Note: We can depend on ccommon_rs for testing purposes
+#       but not otherwise to avoid circular dependencies.
+[dev-dependencies]
+ccommon-rs = { path = "../ccommon-rs" }
diff --git a/rust/ccommon-backend/src/c_export.rs b/rust/ccommon-backend/src/c_export.rs
new file mode 100644
index 000000000..ea5b35d18
--- /dev/null
+++ b/rust/ccommon-backend/src/c_export.rs
@@ -0,0 +1,146 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ccommon_sys::{option, rstatus_i, CC_ENOMEM, CC_ERROR};
+use libc::{c_char, c_uint, FILE};
+
+use std::ffi::CStr;
+use std::io::BufReader;
+
+use crate::compat::CFileRef;
+
+const CC_OK: rstatus_i = ccommon_sys::CC_OK as rstatus_i;
+
+/// Set an option using the value parsed from the string.
+///
+/// Returns 0 for success, otherwise prints an error message
+/// and returns an error code.
+#[no_mangle]
+unsafe extern "C" fn option_set(opt: *mut option, val_str: *const c_char) -> rstatus_i {
+    use crate::option::ParseErrorKind;
+
+    assert!(!val_str.is_null());
+    assert!(!opt.is_null());
+
+    let s = CStr::from_ptr(val_str);
+    let bytes = s.to_bytes();
+
+    match crate::option::option_set(&mut *opt, bytes) {
+        Ok(()) => CC_OK,
+        Err(e) => {
+            eprintln!("Failed to parse option value: {}", e);
+
+            match e.kind() {
+                ParseErrorKind::OutOfMemory => CC_ENOMEM,
+                _ => CC_ERROR,
+            }
+        }
+    }
+}
+
+/// Initialize an option to it's default value.
+///
+/// Returns `0` for success, otherise prints an error message
+/// and returns `CC_ENOMEM`.
+///
+/// Note: The only case where an error can occur here is when
+///       we fail to allocate memory for a string.
+#[no_mangle]
+unsafe extern "C" fn option_default(opt: *mut option) -> rstatus_i {
+    assert!(!opt.is_null());
+
+    match crate::option::option_default(&mut *opt) {
+        Ok(()) => CC_OK,
+        Err(_) => {
+            // This seems unlikely to work if we ran out of memory
+            // while trying to set an option. Myabe it was a really
+            // big string?
+            eprintln!("Ran out of memory while attempting to set option to default");
+
+            CC_ENOMEM
+        }
+    }
+}
+
+/// Print a single option stdout.
+///
+/// Will panic if printing to stdout fails.
+#[no_mangle]
+unsafe extern "C" fn option_print(opt: *const option) {
+    assert!(!opt.is_null());
+
+    crate::option::option_print(&mut std::io::stdout(), &*opt).expect("Failed to write to stdout");
+}
+
+/// Print all options in an array.
+///
+/// Will panic if printing to stdout fails.
+#[no_mangle]
+unsafe extern "C" fn option_print_all(opts: *const option, nopt: c_uint) {
+    let slice = std::slice::from_raw_parts(opts, nopt as usize);
+
+    crate::option::option_print_all(&mut std::io::stdout(), slice)
+        .expect("Failed to write to stdout");
+}
+
+/// Print a description of all options in an array.
+///
+/// Will panic if printing to stdout fails.
+#[no_mangle]
+unsafe extern "C" fn option_describe_all(opts: *const option, nopt: c_uint) {
+    let slice = std::slice::from_raw_parts(opts, nopt as usize);
+
+    crate::option::option_describe_all(&mut std::io::stdout(), slice)
+        .expect("Failed to write to stdout");
+}
+
+/// Initialize an array of options to the default values.
+///
+/// This returns `CC_OK` on success and `CC_ENOMEM` if it
+/// failed to allocate memory for a string copy.
+#[no_mangle]
+unsafe extern "C" fn option_load_default(opts: *mut option, nopt: c_uint) -> rstatus_i {
+    let slice = std::slice::from_raw_parts_mut(opts, nopt as usize);
+
+    match crate::option::option_load_default(slice) {
+        Ok(()) => CC_OK,
+        Err(_) => CC_ENOMEM,
+    }
+}
+
+/// Parse options in `.ini` format from a file.
+///
+/// Returns 0 on success. On error prints out an error message
+/// and returns a non-zero error code.
+#[no_mangle]
+unsafe extern "C" fn option_load_file(fp: *mut FILE, opts: *mut option, nopt: c_uint) -> rstatus_i {
+    use crate::option::ParseErrorKind;
+
+    let slice = std::slice::from_raw_parts_mut(opts, nopt as usize);
+    let file = CFileRef::from_ptr_mut(fp);
+    let mut file = BufReader::new(file);
+
+    match crate::option::option_load(slice, &mut file) {
+        Ok(()) => CC_OK,
+        Err(e) => {
+            eprintln!("Failed to load options from file: {}", e);
+
+            match e.kind() {
+                ParseErrorKind::OutOfMemory => CC_ENOMEM,
+                _ => CC_ERROR,
+            }
+        }
+    }
+}
diff --git a/rust/ccommon-backend/src/compat.rs b/rust/ccommon-backend/src/compat.rs
new file mode 100644
index 000000000..c9fc4cbf8
--- /dev/null
+++ b/rust/ccommon-backend/src/compat.rs
@@ -0,0 +1,157 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use libc::{
+    c_long, c_void, feof, fflush, fread, fseek, ftell, fwrite, FILE, SEEK_CUR, SEEK_END, SEEK_SET,
+};
+use std::io::{Error, ErrorKind, Read, Result, Seek, SeekFrom, Write};
+
+/// A reference to a C `FILE` instance.
+///
+/// This is a convenience wrapper that supports `Read`, `Write`
+/// and `Seek` from [`std::io`][io]. It does not take any ownership
+/// over the `FILE` pointer.
+///
+/// [io]: std::io
+pub struct CFileRef {
+    _ptr: FILE,
+}
+
+impl CFileRef {
+    /// Create a new reference from a const file pointer.
+    ///
+    /// # Safety
+    /// It is undefined behaviour
+    /// - To call this function with an invalid pointer.
+    /// - If the reference created through this function outlives
+    ///   the original pointer
+    /// - If the pointer is modified while the reference is still live.
+    ///
+    /// # Panics
+    /// This function will panic if `ptr` is null.
+    pub unsafe fn from_ptr<'a>(ptr: *const FILE) -> &'a Self {
+        assert!(!ptr.is_null());
+
+        &*(ptr as *const Self)
+    }
+
+    /// Create a new reference from a mutable file pointer.
+    ///
+    /// # Safety
+    /// It is undefined behaviour
+    /// - To call this function with an invalid pointer.
+    /// - If the reference created through this function outlives
+    ///   the original pointer
+    /// - If the pointer is modified while the reference is still live.
+    ///
+    /// # Panics
+    /// This function will panic if `ptr` is null.
+    pub unsafe fn from_ptr_mut<'a>(ptr: *mut FILE) -> &'a mut Self {
+        assert!(!ptr.is_null());
+
+        &mut *(ptr as *mut Self)
+    }
+
+    /// Convert the reference back to a `FILE` pointer.
+    pub fn as_ptr(&self) -> *const FILE {
+        self as *const Self as *const FILE
+    }
+
+    /// Convert the reference back to a `FILE` pointer.
+    pub fn as_mut_ptr(&mut self) -> *mut FILE {
+        self as *mut Self as *mut FILE
+    }
+}
+
+impl Write for CFileRef {
+    fn write(&mut self, bytes: &[u8]) -> Result<usize> {
+        let written = unsafe {
+            fwrite(
+                bytes.as_ptr() as *const c_void,
+                1,
+                bytes.len(),
+                self.as_mut_ptr(),
+            )
+        };
+
+        if written != bytes.len() {
+            return Err(Error::last_os_error());
+        }
+
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> Result<()> {
+        let res = unsafe { fflush(self.as_mut_ptr()) };
+
+        if res != 0 {
+            Err(Error::last_os_error())
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl Read for CFileRef {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let read = unsafe {
+            fread(
+                buf.as_mut_ptr() as *mut c_void,
+                1,
+                buf.len(),
+                self.as_mut_ptr(),
+            )
+        };
+
+        if read == buf.len() {
+            return Ok(read);
+        }
+
+        if unsafe { feof(self.as_mut_ptr()) != 0 } {
+            return Ok(read);
+        }
+
+        Err(Error::last_os_error())
+    }
+}
+
+impl Seek for CFileRef {
+    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
+        use std::convert::TryInto;
+
+        let (offset, origin) = match pos {
+            SeekFrom::Start(offset) => (offset as i64, SEEK_SET),
+            SeekFrom::Current(offset) => (offset, SEEK_CUR),
+            SeekFrom::End(offset) => (offset, SEEK_END),
+        };
+
+        let offset: c_long = match offset.try_into() {
+            Ok(off) => off,
+            Err(e) => return Err(Error::new(ErrorKind::Other, Box::new(e))),
+        };
+
+        let ret = unsafe { fseek(self.as_mut_ptr(), offset, origin) };
+        if ret != 0 {
+            return Err(Error::last_os_error());
+        }
+
+        let off = unsafe { ftell(self.as_mut_ptr()) };
+        if off < 0 {
+            return Err(Error::last_os_error());
+        }
+
+        Ok(off as u64)
+    }
+}
diff --git a/rust/ccommon-backend/src/lib.rs b/rust/ccommon-backend/src/lib.rs
new file mode 100644
index 000000000..441143e8e
--- /dev/null
+++ b/rust/ccommon-backend/src/lib.rs
@@ -0,0 +1,41 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Rust reimplementations of parts of ccommon.
+//!
+//! This is a separate library as it is intended to be used as a dependency
+//! on C code within ccommon.
+
+pub mod option {
+    mod default;
+    mod parse;
+    mod print;
+
+    pub use self::default::{option_default, option_load_default, OutOfMemoryError};
+    pub use self::parse::{option_load, option_set, ParseError, ParseErrorKind};
+    pub use self::print::{option_describe, option_describe_all, option_print, option_print_all};
+}
+
+pub mod compat;
+
+#[cfg(feature = "c-export")]
+mod c_export;
+
+/// Rexports of the functions defined in this crate that correspond
+/// to the C functions used in ccommon.
+#[cfg(feature = "c-export")]
+pub mod c {
+    pub use crate::c_export::*;
+}
diff --git a/rust/ccommon-backend/src/option/default.rs b/rust/ccommon-backend/src/option/default.rs
new file mode 100644
index 000000000..f0955257d
--- /dev/null
+++ b/rust/ccommon-backend/src/option/default.rs
@@ -0,0 +1,99 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ccommon_sys::{
+    _cc_alloc, option, OPTION_TYPE_BOOL, OPTION_TYPE_FPN, OPTION_TYPE_STR, OPTION_TYPE_UINT,
+};
+
+use std::convert::TryInto;
+use std::ffi::CStr;
+use std::fmt;
+
+macro_rules! c_str {
+    ($s:expr) => {
+        concat!($s, "\0").as_ptr() as *const i8
+    };
+}
+
+#[derive(Debug)]
+pub struct OutOfMemoryError(());
+
+impl fmt::Display for OutOfMemoryError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Out of memory")
+    }
+}
+
+impl std::error::Error for OutOfMemoryError {}
+
+/// Initialize an option to it's default value.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_default(opt: &mut option) -> Result<(), OutOfMemoryError> {
+    use std::mem::MaybeUninit;
+
+    opt.set = true;
+
+    match opt.type_ {
+        OPTION_TYPE_BOOL => opt.val.vbool = opt.default_val.vbool,
+        OPTION_TYPE_UINT => opt.val.vuint = opt.default_val.vuint,
+        OPTION_TYPE_FPN => opt.val.vfpn = opt.default_val.vfpn,
+        OPTION_TYPE_STR => {
+            let default = opt.default_val.vstr;
+
+            if default.is_null() {
+                opt.val.vstr = default;
+            } else {
+                let s = CStr::from_ptr(default);
+                let bytes = s.to_bytes_with_nul();
+                let mem = _cc_alloc(
+                    bytes.len().try_into().unwrap(),
+                    c_str!(module_path!()),
+                    line!() as std::os::raw::c_int,
+                ) as *mut MaybeUninit<u8>;
+
+                if mem.is_null() {
+                    return Err(OutOfMemoryError(()));
+                }
+
+                std::ptr::copy_nonoverlapping(bytes.as_ptr(), mem as *mut u8, bytes.len());
+
+                opt.val.vstr = mem as *mut libc::c_char
+            }
+        }
+        _ => opt.val = opt.default_val,
+    };
+
+    Ok(())
+}
+
+/// Initialize all the options to their default values.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_load_default(options: &mut [option]) -> Result<(), OutOfMemoryError> {
+    for opt in options.iter_mut() {
+        option_default(opt)?;
+    }
+
+    Ok(())
+}
diff --git a/rust/ccommon-backend/src/option/parse.rs b/rust/ccommon-backend/src/option/parse.rs
new file mode 100644
index 000000000..970daf23c
--- /dev/null
+++ b/rust/ccommon-backend/src/option/parse.rs
@@ -0,0 +1,519 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Disabling this lint since I find that the usage of the lifetimes
+// in this file makes things clearer.
+#![allow(clippy::needless_lifetimes)]
+
+use ccommon_sys::{
+    option, option_type, OPTION_TYPE_BOOL, OPTION_TYPE_FPN, OPTION_TYPE_STR, OPTION_TYPE_UINT,
+};
+
+use std::borrow::Cow;
+use std::convert::TryInto;
+use std::error::Error;
+use std::ffi::CStr;
+use std::fmt;
+use std::io::{BufRead, Error as IOError};
+
+macro_rules! c_str {
+    ($s:expr) => {
+        concat!($s, "\0").as_ptr() as *const i8
+    };
+}
+
+/// Error for when a config file fails to parse.
+///
+/// This covers everything from an IO error to running out of memory
+/// to a missing colon within a line.
+pub struct ParseError<'a> {
+    span: Span<'a>,
+    data: ParseErrorType,
+}
+
+impl<'a> ParseError<'a> {
+    pub fn kind(&self) -> ParseErrorKind {
+        match &self.data {
+            ParseErrorType::InvalidBool => ParseErrorKind::InvalidBool,
+            ParseErrorType::InvalidUInt => ParseErrorKind::InvalidUInt,
+            ParseErrorType::StringWithNull => ParseErrorKind::InvalidString,
+            ParseErrorType::InvalidFloat => ParseErrorKind::InvalidFloat,
+            ParseErrorType::NoColonInLine => ParseErrorKind::IncorrectKVSyntax,
+            ParseErrorType::UnknownOptionType => ParseErrorKind::UnknownOptionType,
+            ParseErrorType::OutOfMemory => ParseErrorKind::OutOfMemory,
+            ParseErrorType::IOError(_) => ParseErrorKind::IOError,
+            ParseErrorType::InvalidKey => ParseErrorKind::UnknownOption,
+        }
+    }
+}
+
+impl<'a> ParseError<'a> {
+    fn invalid_bool(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::InvalidBool,
+        }
+    }
+
+    fn invalid_uint(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::InvalidUInt,
+        }
+    }
+
+    fn invalid_fpn(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::InvalidFloat,
+        }
+    }
+
+    fn string_contained_null(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::StringWithNull,
+        }
+    }
+
+    fn invalid_key(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::InvalidKey,
+        }
+    }
+
+    fn missing_colon(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::NoColonInLine,
+        }
+    }
+
+    fn unknown_option_type(span: Span<'a>) -> Self {
+        Self {
+            span,
+            data: ParseErrorType::UnknownOptionType,
+        }
+    }
+
+    fn ioerror(err: IOError) -> Self {
+        Self {
+            span: Span::new(&[], 0),
+            data: ParseErrorType::IOError(err),
+        }
+    }
+
+    fn oom() -> Self {
+        Self {
+            span: Span {
+                line: 0,
+                text: Cow::Borrowed(&[]),
+            },
+            data: ParseErrorType::OutOfMemory,
+        }
+    }
+
+    fn into_owned(self) -> ParseError<'static> {
+        ParseError {
+            span: Span {
+                line: self.span.line,
+                text: Cow::Owned(self.span.text.into_owned()),
+            },
+            data: self.data,
+        }
+    }
+}
+
+#[derive(Debug)]
+enum ParseErrorType {
+    InvalidBool,
+    InvalidUInt,
+    StringWithNull,
+    InvalidFloat,
+
+    InvalidKey,
+    UnknownOptionType,
+    NoColonInLine,
+    IOError(IOError),
+    OutOfMemory,
+}
+
+/// The type of the parse error,
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ParseErrorKind {
+    /// Tried to parse a bool, but it wasn't valid.
+    InvalidBool,
+    /// Tried to parse an unsigned integer, but it wasn't valid.
+    InvalidUInt,
+    /// Tried to parse a string, but it contained a nul character
+    InvalidString,
+    /// Tried to parse a float, but it wasn't valid.
+    InvalidFloat,
+    /// Tried to parse a `key: value` pair but a colon was missing.
+    IncorrectKVSyntax,
+
+    /// Parsed a valid option, but it doesn't correspond to any
+    /// of the options that were provided.
+    UnknownOption,
+    /// An option had an unrecognized option type.
+    UnknownOptionType,
+    /// Was unable to allocate memory when it was needed while parsing.
+    ///
+    /// Note that this doesn't apply to all OOM cases.
+    OutOfMemory,
+    /// An IO error occurred when reading from the stream.
+    IOError,
+}
+
+/// Load options from a type which implements `BufRead`.
+///
+/// In most cases you'll want to use [`OptionExt::load`][0]
+/// instead.
+///
+/// [0]: crate::option::OptionExt::load
+pub fn option_load<R: BufRead>(
+    options: &mut [option],
+    source: &mut R,
+) -> Result<(), ParseError<'static>> {
+    let mut linebuf = Vec::new();
+
+    let mut lineno = 0;
+
+    while source
+        .read_until(b'\n', &mut linebuf)
+        .map_err(ParseError::ioerror)?
+        != 0
+    {
+        // Strip off any comments before doing parsing
+        let line = linebuf.split(|&x| x == b'#').next().unwrap();
+
+        if line.iter().copied().all(|x| x.is_ascii_whitespace()) {
+            linebuf.clear();
+            continue;
+        }
+
+        let (k, v) = parse_kv(&line, lineno).map_err(|x| x.into_owned())?;
+
+        let opt = match unsafe { find_option(options, k) } {
+            Some(opt) => opt,
+            None => return Err(ParseError::invalid_key(Span::new(k, lineno)).into_owned()),
+        };
+
+        let value = parse_value(v, lineno, opt.type_).map_err(|x| x.into_owned())?;
+        unsafe { set_option_value(opt, value)? };
+
+        lineno += 1;
+        linebuf.clear();
+    }
+
+    Ok(())
+}
+
+/// Load a single option from a byte string.
+pub fn option_set<'a>(option: &mut option, value: &'a [u8]) -> Result<(), ParseError<'a>> {
+    let value = parse_value(value, 0, option.type_)?;
+
+    unsafe { set_option_value(option, value) }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+struct Span<'a> {
+    text: Cow<'a, [u8]>,
+    line: u32,
+}
+
+impl<'a> Span<'a> {
+    pub fn new(text: &'a [u8], line: u32) -> Self {
+        Self {
+            text: Cow::Borrowed(text),
+            line,
+        }
+    }
+}
+
+enum Value<'a> {
+    Str(&'a [u8]),
+    Float(f64),
+    UInt(u64),
+    Bool(bool),
+}
+
+fn is_space(c: Option<u8>) -> bool {
+    c.map(|x| x.is_ascii_whitespace()).unwrap_or(false)
+}
+
+/// Trim starting and ending spaces off of a byte slice
+fn trim_bytes(mut slice: &[u8]) -> &[u8] {
+    while is_space(slice.first().copied()) {
+        slice = slice.split_first().unwrap().1;
+    }
+
+    while is_space(slice.last().copied()) {
+        slice = slice.split_last().unwrap().1
+    }
+
+    slice
+}
+
+/// Parse a key-value pair separated by `:` then strip the whitespace
+/// off of both the key and the value.
+fn parse_kv<'a>(input: &'a [u8], line: u32) -> Result<(&'a [u8], &'a [u8]), ParseError<'a>> {
+    let mut first = true;
+
+    let mut split = input.split(|&x| {
+        if x == b':' && first {
+            first = false;
+            return true;
+        }
+
+        false
+    });
+
+    let key = match split.next() {
+        Some(x) => x,
+        // There will always be at least one subslice
+        None => unreachable!(),
+    };
+    let value = match split.next() {
+        Some(x) => x,
+        None => return Err(ParseError::missing_colon(Span::new(input, line))),
+    };
+
+    let key = trim_bytes(key);
+
+    if !is_valid_name(key) {
+        return Err(ParseError::invalid_key(Span::new(key, line)));
+    }
+
+    Ok((key, trim_bytes(value)))
+}
+
+/// Validate a key name.
+///
+/// A valid key can only contain characters in `[a-zA-Z0-9_]`.
+fn is_valid_name(key: &[u8]) -> bool {
+    key.iter()
+        .copied()
+        .all(|x: u8| x.is_ascii_alphanumeric() || x == b'_')
+}
+
+/// Parse an unsigned integer. Does not implement expression handling
+/// that was present in the original ccommon implmentation since it
+/// was deemed that it probably wasn't needed.
+fn parse_uint<'a>(input: &'a [u8], line: u32) -> Result<u64, ParseError<'a>> {
+    use std::str;
+
+    let s = str::from_utf8(input).map_err(|_| ParseError::invalid_uint(Span::new(input, line)))?;
+
+    s.parse()
+        .map_err(|_| ParseError::invalid_uint(Span::new(input, line)))
+}
+
+/// Parse a string value. The only thing this method does is verify that
+/// the string doesn't contain any nul characters.
+fn parse_str<'a>(input: &'a [u8], line: u32) -> Result<&'a [u8], ParseError<'a>> {
+    if input.iter().any(|&c| c == 0) {
+        return Err(ParseError::string_contained_null(Span::new(input, line)));
+    }
+
+    Ok(input)
+}
+
+/// Parse a boolean. A boolean is either the literal `yes` or the literal `no.
+fn parse_bool<'a>(input: &'a [u8], line: u32) -> Result<bool, ParseError<'a>> {
+    match input {
+        b"yes" => Ok(true),
+        b"no" => Ok(false),
+        _ => Err(ParseError::invalid_bool(Span::new(input, line))),
+    }
+}
+
+/// Parse a floating point number. This just calls `f64::parse`.
+fn parse_fpn<'a>(input: &'a [u8], line: u32) -> Result<f64, ParseError<'a>> {
+    use std::str;
+
+    let s = str::from_utf8(input).map_err(|_| ParseError::invalid_fpn(Span::new(input, line)))?;
+
+    s.parse()
+        .map_err(|_| ParseError::invalid_fpn(Span::new(input, line)))
+}
+
+/// Given the type of the option, parse a value
+fn parse_value<'a>(
+    input: &'a [u8],
+    line: u32,
+    ty: option_type,
+) -> Result<Value<'a>, ParseError<'a>> {
+    match ty {
+        OPTION_TYPE_UINT => Ok(Value::UInt(parse_uint(input, line)?)),
+        OPTION_TYPE_BOOL => Ok(Value::Bool(parse_bool(input, line)?)),
+        OPTION_TYPE_STR => Ok(Value::Str(parse_str(input, line)?)),
+        OPTION_TYPE_FPN => Ok(Value::Float(parse_fpn(input, line)?)),
+
+        _ => Err(ParseError::unknown_option_type(Span::new(input, line))),
+    }
+}
+
+/// Search for a named option within the options array.
+unsafe fn find_option<'a>(options: &'a mut [option], name: &[u8]) -> Option<&'a mut option> {
+    for opt in options.iter_mut() {
+        assert!(!opt.name.is_null());
+
+        let opt_name = CStr::from_ptr(opt.name);
+
+        if opt_name.to_bytes() == name {
+            return Some(opt);
+        }
+    }
+
+    None
+}
+
+unsafe fn set_option_value(option: &mut option, value: Value) -> Result<(), ParseError<'static>> {
+    use ccommon_sys::{_cc_alloc, _cc_free};
+    use std::mem::MaybeUninit;
+
+    match value {
+        Value::Bool(v) => option.val.vbool = v,
+        Value::Float(v) => option.val.vfpn = v,
+        Value::UInt(v) => option.val.vuint = v,
+        Value::Str(v) => {
+            if option.set && !option.val.vstr.is_null() {
+                // Avoid leaking memory in the case where the option has
+                // already been initialized.
+                _cc_free(
+                    option.val.vstr as *mut libc::c_void,
+                    c_str!(module_path!()),
+                    line!() as std::os::raw::c_int,
+                );
+            }
+
+            let mem = _cc_alloc(
+                (v.len() + 1).try_into().unwrap(),
+                c_str!(module_path!()),
+                line!() as std::os::raw::c_int,
+            ) as *mut MaybeUninit<u8>;
+
+            if mem.is_null() {
+                return Err(ParseError::oom());
+            }
+
+            // Copy the string over
+            std::ptr::copy_nonoverlapping(v.as_ptr() as *const MaybeUninit<u8>, mem, v.len());
+
+            // Add nul terminator
+            std::ptr::write(mem.wrapping_add(v.len()), MaybeUninit::new(0));
+
+            option.val.vstr = mem as *mut i8
+        }
+    }
+
+    option.set = true;
+
+    Ok(())
+}
+
+fn escape_string(bytes: &[u8]) -> String {
+    bytes
+        .iter()
+        .flat_map(|x| std::ascii::escape_default(*x))
+        .map(|c| c as char)
+        .collect()
+}
+
+impl fmt::Debug for Value<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Value::Bool(v) => fmt.debug_tuple("Bool").field(v).finish(),
+            Value::Float(v) => fmt.debug_tuple("Float").field(v).finish(),
+            Value::UInt(v) => fmt.debug_tuple("UInt").field(v).finish(),
+            Value::Str(s) => {
+                let escaped = &escape_string(s);
+                fmt.debug_tuple("Str").field(escaped).finish()
+            }
+        }
+    }
+}
+
+impl fmt::Display for ParseError<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        use ParseErrorType::*;
+
+        let spanmsg: String = (*self.span.text)
+            .iter()
+            .copied()
+            .flat_map(std::ascii::escape_default)
+            .map(|c| c as char)
+            .collect();
+
+        match &self.data {
+            InvalidBool => write!(
+                fmt,
+                "line {}: '{}' is not a valid boolean expression, expected 'yes' or 'no'",
+                self.span.line, spanmsg
+            ),
+            InvalidUInt => write!(
+                fmt,
+                "line {}: '{}' is not a valid integer",
+                self.span.line, spanmsg
+            ),
+            StringWithNull => write!(
+                fmt,
+                "line {}: string literal contained nul character",
+                self.span.line
+            ),
+            InvalidFloat => write!(
+                fmt,
+                "line {}: '{}' is not a valid floating point number",
+                self.span.line, spanmsg
+            ),
+            InvalidKey => write!(
+                fmt,
+                "line {}: option '{}' not recognized",
+                self.span.line, spanmsg
+            ),
+            UnknownOptionType => write!(fmt, "unknown option type"),
+            NoColonInLine => write!(
+                fmt,
+                "line {}: invalid formatting, expected '<key>: <value>'",
+                self.span.line
+            ),
+            IOError(e) => write!(fmt, "IO error: {}", e),
+            OutOfMemory => write!(fmt, "ran out of memory while parsing file"),
+        }
+    }
+}
+
+impl fmt::Debug for ParseError<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        // Create a debug representation that actually shows the error
+        // message since the internals are fairly unhelpful when they
+        // show up in a `unwrap` or `expect` call.
+        fmt.debug_struct("ParseError")
+            .field("message", &format_args!("{}", self))
+            .field("kind", &self.kind())
+            .finish()
+    }
+}
+
+impl<'a> Error for ParseError<'a> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match &self.data {
+            ParseErrorType::IOError(e) => Some(e),
+            _ => None,
+        }
+    }
+}
diff --git a/rust/ccommon-backend/src/option/print.rs b/rust/ccommon-backend/src/option/print.rs
new file mode 100644
index 000000000..9f5c4731e
--- /dev/null
+++ b/rust/ccommon-backend/src/option/print.rs
@@ -0,0 +1,120 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ccommon_sys::{
+    option, option_type, option_val, OPTION_TYPE_BOOL, OPTION_TYPE_FPN, OPTION_TYPE_STR,
+    OPTION_TYPE_UINT,
+};
+
+use std::ffi::CStr;
+use std::io::{Result, Write};
+
+unsafe fn fmt_cstr(ptr: *const libc::c_char) -> &'static str {
+    CStr::from_ptr(ptr).to_str().unwrap()
+}
+
+fn fmt_type(ty: option_type) -> &'static str {
+    match ty {
+        OPTION_TYPE_BOOL => "bool",
+        OPTION_TYPE_UINT => "unsigned int",
+        OPTION_TYPE_FPN => "double",
+        OPTION_TYPE_STR => "string",
+        _ => "<unknown>",
+    }
+}
+
+fn fmt_value<W: Write>(writer: &mut W, val: option_val, ty: option_type) -> Result<()> {
+    unsafe {
+        match ty {
+            OPTION_TYPE_BOOL => write!(writer, "{: <20}", if val.vbool { "yes" } else { "no" }),
+            OPTION_TYPE_UINT => write!(writer, "{: <20}", val.vuint),
+            OPTION_TYPE_FPN => write!(writer, "{: <20}", val.vfpn),
+            OPTION_TYPE_STR => {
+                if val.vstr.is_null() {
+                    write!(writer, "{: <20}", "NULL")
+                } else {
+                    write!(writer, "{: <20}", fmt_cstr(val.vstr))
+                }
+            }
+            _ => write!(writer, "{: <20}", "<unknown>"),
+        }
+    }
+}
+
+/// Print a single option.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_print<W: Write>(writer: &mut W, opt: &option) -> Result<()> {
+    write!(
+        writer,
+        "name: {: <31} type: {: <15} current: ",
+        fmt_cstr(opt.name),
+        fmt_type(opt.type_)
+    )?;
+    fmt_value(writer, opt.val, opt.type_)?;
+    write!(writer, " (default: ")?;
+    fmt_value(writer, opt.default_val, opt.type_)?;
+    writeln!(writer, ")")
+}
+
+/// Print all options.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_print_all<W: Write>(writer: &mut W, options: &[option]) -> Result<()> {
+    for opt in options.iter() {
+        option_print(writer, opt)?;
+    }
+
+    Ok(())
+}
+
+/// Describe a single option.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_describe<W: Write>(writer: &mut W, opt: &option) -> Result<()> {
+    let name = fmt_cstr(opt.name);
+    let desc = fmt_cstr(opt.description);
+
+    write!(writer, "{: <31} {: <15} ", name, fmt_type(opt.type_))?;
+    fmt_value(writer, opt.default_val, opt.type_)?;
+    writeln!(writer, " {}\n", desc)
+}
+
+/// Describe all options.
+///
+/// # Safety
+/// This function assumes that the description and name
+/// pointers within the options always point to a valid
+/// C string. It also assumes that the value for string
+/// type options is either a valid C string or null.
+pub unsafe fn option_describe_all<W: Write>(writer: &mut W, options: &[option]) -> Result<()> {
+    for opt in options.iter() {
+        option_describe(writer, opt)?;
+    }
+
+    Ok(())
+}
diff --git a/rust/ccommon-backend/tests/parse.rs b/rust/ccommon-backend/tests/parse.rs
new file mode 100644
index 000000000..f6b253ac5
--- /dev/null
+++ b/rust/ccommon-backend/tests/parse.rs
@@ -0,0 +1,190 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ccommon_backend::option::*;
+use ccommon_rs::{option::*, Options};
+
+use std::ffi::CStr;
+use std::io::Cursor;
+
+#[derive(Options)]
+#[repr(C)]
+pub struct TestOptions {
+    #[option(desc = "float option")]
+    fpn_option: Float,
+    #[option(desc = "uint option")]
+    uint_option: UInt,
+    #[option(desc = "bool option")]
+    bool_option: Bool,
+    #[option(desc = "string option")]
+    str_option: Str,
+}
+
+macro_rules! c_str_ffi {
+    ($s:expr) => {
+        unsafe { CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes()) }
+    };
+}
+
+fn cstr_to_str(ptr: *const libc::c_char) -> Option<&'static str> {
+    if ptr.is_null() {
+        return None;
+    }
+
+    unsafe {
+        let cstr = CStr::from_ptr(ptr);
+        Some(cstr.to_str().unwrap())
+    }
+}
+
+#[test]
+fn parse_sanity_test() {
+    let mut options = TestOptions::new();
+    let config: &[u8] = br#"
+            fpn_option: 53.1
+            uint_option: 1000
+            bool_option: yes
+            str_option: Hello, World!
+        "#;
+
+    let mut cursor = Cursor::new(config);
+    options.load(&mut cursor).expect("Failed to parse config");
+
+    assert_eq!(options.fpn_option.value(), 53.1);
+    assert_eq!(options.uint_option.value(), 1000);
+    assert_eq!(options.bool_option.value(), true);
+    assert_eq!(
+        options.str_option.as_cstr(),
+        Some(c_str_ffi!("Hello, World!"))
+    );
+}
+
+#[test]
+fn unknown_option() {
+    let mut options = TestOptions::new();
+    let config: &[u8] = b"unknown: FOO";
+
+    let mut cursor = Cursor::new(config);
+    let err = options.load(&mut cursor).unwrap_err();
+
+    assert_eq!(err.kind(), ParseErrorKind::UnknownOption);
+}
+
+#[test]
+fn parse_bool() {
+    let mut options = TestOptions::new();
+    let config1: &[u8] = b"bool_option: yes";
+    let config2: &[u8] = b"bool_option: no";
+
+    let mut cursor1 = Cursor::new(config1);
+    options.load(&mut cursor1).unwrap();
+
+    assert_eq!(options.bool_option.value(), true);
+
+    let mut cursor2 = Cursor::new(config2);
+    options.load(&mut cursor2).unwrap();
+
+    assert_eq!(options.bool_option.value(), false);
+}
+
+#[test]
+fn overlarge_uint() {
+    let mut options = TestOptions::new();
+    let config: &[u8] = b"uint_option: 100000000000000000000000000000000000000000";
+
+    let mut cursor = Cursor::new(config);
+    let err = options.load(&mut cursor).unwrap_err();
+
+    assert_eq!(err.kind(), ParseErrorKind::InvalidUInt);
+}
+
+#[test]
+fn non_colon_separated_line() {
+    let mut options = TestOptions::new();
+    let config: &[u8] = b"foobar";
+
+    let mut cursor = Cursor::new(config);
+    let err = options.load(&mut cursor).unwrap_err();
+
+    assert_eq!(err.kind(), ParseErrorKind::IncorrectKVSyntax);
+}
+
+#[test]
+fn test_parse_uint() {
+    let mut options = TestOptions::new();
+
+    let mut cursor = Cursor::new(b"uint_option: invalid");
+    assert!(options.load(&mut cursor).is_err());
+
+    let mut cursor = Cursor::new(b"uint_option: -1");
+    assert!(options.load(&mut cursor).is_err());
+
+    let mut cursor = Cursor::new(b"uint_option: 1");
+    options.load(&mut cursor).unwrap();
+    assert_eq!(options.uint_option.value(), 1);
+
+    let mut cursor = Cursor::new(b"uint_option: 1A");
+    assert!(options.load(&mut cursor).is_err());
+}
+
+#[test]
+fn test_parse_float() {
+    let mut options = TestOptions::new();
+
+    let mut cursor = Cursor::new(b"fpn_option: invalid");
+    assert!(options.load(&mut cursor).is_err());
+
+    let mut cursor = Cursor::new(b"fpn_option: 1.0e-5X");
+    assert!(options.load(&mut cursor).is_err());
+
+    let mut cursor = Cursor::new(&b"fpn_option: 1.0e10000000000000000000000"[..]);
+    options.load(&mut cursor).unwrap();
+    assert!(options.fpn_option.value().is_infinite());
+
+    let mut cursor = Cursor::new("fpn_option: 1.0");
+    options.load(&mut cursor).unwrap();
+    assert_eq!(options.fpn_option.value(), 1.0);
+
+    let mut cursor = Cursor::new("fpn_option: -1e20");
+    options.load(&mut cursor).unwrap();
+    assert_eq!(options.fpn_option.value(), -1e20);
+}
+
+#[test]
+fn test_parse_string() {
+    let mut options = TestOptions::new();
+
+    let mut cursor = Cursor::new(b"str_option: foo");
+    options.load(&mut cursor).unwrap();
+    assert_eq!(cstr_to_str(options.str_option.value()), Some("foo"));
+
+    let mut cursor = Cursor::new(b"str_option: foo\0bar");
+    assert!(options.load(&mut cursor).is_err());
+}
+
+#[test]
+fn test_parse_comments() {
+    let mut options = TestOptions::new();
+
+    let mut cursor = Cursor::new(
+        &br#"
+        # Test Comment
+        uint_option: 22
+        # uint_option: 34
+    "#[..],
+    );
+    options.load(&mut cursor).unwrap();
+    assert_eq!(options.uint_option.value(), 22);
+}
diff --git a/rust/ccommon-buffer/CMakeLists.txt b/rust/ccommon-buffer/CMakeLists.txt
new file mode 100644
index 000000000..ccc692e49
--- /dev/null
+++ b/rust/ccommon-buffer/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-buffer)
diff --git a/rust/ccommon-buffer/Cargo.toml b/rust/ccommon-buffer/Cargo.toml
new file mode 100644
index 000000000..d85403041
--- /dev/null
+++ b/rust/ccommon-buffer/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "ccommon-buffer"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
+
diff --git a/rust/ccommon-buffer/src/buf/mod.rs b/rust/ccommon-buffer/src/buf/mod.rs
new file mode 100644
index 000000000..fd8da24d5
--- /dev/null
+++ b/rust/ccommon-buffer/src/buf/mod.rs
@@ -0,0 +1,50 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const BUF_DEFAULT_SIZE: usize = 16 * 1024;
+const BUF_POOLSIZE: usize = 0;
+
+// helper functions
+fn size() -> usize {
+    BUF_DEFAULT_SIZE
+}
+
+fn poolsize() -> usize {
+    BUF_POOLSIZE
+}
+
+// struct definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct BufConfig {
+    #[cfg_attr(feature = "serde", serde(default = "size"))]
+    size: usize,
+    #[cfg_attr(feature = "serde", serde(default = "poolsize"))]
+    poolsize: usize,
+}
+
+// implementation
+impl BufConfig {
+    pub fn size(&self) -> usize {
+        self.size
+    }
+
+    pub fn poolsize(&self) -> usize {
+        self.poolsize
+    }
+}
+
+// trait implementations
+impl Default for BufConfig {
+    fn default() -> Self {
+        Self {
+            size: size(),
+            poolsize: poolsize(),
+        }
+    }
+}
diff --git a/rust/ccommon-buffer/src/dbuf/mod.rs b/rust/ccommon-buffer/src/dbuf/mod.rs
new file mode 100644
index 000000000..db2724e74
--- /dev/null
+++ b/rust/ccommon-buffer/src/dbuf/mod.rs
@@ -0,0 +1,38 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const DBUF_DEFAULT_MAX: usize = 8;
+
+// helper functions
+fn max_power() -> usize {
+    DBUF_DEFAULT_MAX
+}
+
+// struct definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct DbufConfig {
+    #[cfg_attr(feature = "serde", serde(default = "max_power"))]
+    max_power: usize,
+}
+
+// implementation
+impl DbufConfig {
+    pub fn max_power(&self) -> usize {
+        self.max_power
+    }
+}
+
+// trait implementations
+impl Default for DbufConfig {
+    fn default() -> Self {
+        Self {
+            max_power: max_power(),
+        }
+    }
+}
diff --git a/rust/ccommon-buffer/src/lib.rs b/rust/ccommon-buffer/src/lib.rs
new file mode 100644
index 000000000..00489b149
--- /dev/null
+++ b/rust/ccommon-buffer/src/lib.rs
@@ -0,0 +1,9 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+mod buf;
+mod dbuf;
+
+pub use buf::*;
+pub use dbuf::*;
diff --git a/rust/ccommon-channel/CMakeLists.txt b/rust/ccommon-channel/CMakeLists.txt
new file mode 100644
index 000000000..dc47008ce
--- /dev/null
+++ b/rust/ccommon-channel/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-channel)
diff --git a/rust/ccommon-channel/Cargo.toml b/rust/ccommon-channel/Cargo.toml
new file mode 100644
index 000000000..6bceed653
--- /dev/null
+++ b/rust/ccommon-channel/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "ccommon-channel"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
diff --git a/rust/ccommon-channel/src/lib.rs b/rust/ccommon-channel/src/lib.rs
new file mode 100644
index 000000000..d57a6bc9c
--- /dev/null
+++ b/rust/ccommon-channel/src/lib.rs
@@ -0,0 +1,9 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+mod pipe;
+mod tcp;
+
+pub use pipe::*;
+pub use tcp::*;
diff --git a/rust/ccommon-channel/src/pipe/mod.rs b/rust/ccommon-channel/src/pipe/mod.rs
new file mode 100644
index 000000000..946f90f38
--- /dev/null
+++ b/rust/ccommon-channel/src/pipe/mod.rs
@@ -0,0 +1,38 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const PIPE_POOLSIZE: usize = 0;
+
+// helper functions
+fn poolsize() -> usize {
+    PIPE_POOLSIZE
+}
+
+// definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct PipeConfig {
+    #[cfg_attr(feature = "serde", serde(default = "poolsize"))]
+    poolsize: usize,
+}
+
+// implementation
+impl PipeConfig {
+    pub fn poolsize(&self) -> usize {
+        self.poolsize
+    }
+}
+
+// trait implementations
+impl Default for PipeConfig {
+    fn default() -> Self {
+        Self {
+            poolsize: poolsize(),
+        }
+    }
+}
diff --git a/rust/ccommon-channel/src/tcp/mod.rs b/rust/ccommon-channel/src/tcp/mod.rs
new file mode 100644
index 000000000..125910583
--- /dev/null
+++ b/rust/ccommon-channel/src/tcp/mod.rs
@@ -0,0 +1,50 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const TCP_BACKLOG: usize = 128;
+const TCP_POOLSIZE: usize = 0;
+
+// helper functions
+fn backlog() -> usize {
+    TCP_BACKLOG
+}
+
+fn poolsize() -> usize {
+    TCP_POOLSIZE
+}
+
+// definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct TcpConfig {
+	#[cfg_attr(feature = "serde", serde(default = "backlog"))]
+    backlog: usize,
+    #[cfg_attr(feature = "serde", serde(default = "poolsize"))]
+    poolsize: usize,
+}
+
+// implementation
+impl TcpConfig {
+    pub fn backlog(&self) -> usize {
+        self.backlog
+    }
+
+    pub fn poolsize(&self) -> usize {
+        self.poolsize
+    }
+}
+
+// trait implementations
+impl Default for TcpConfig {
+    fn default() -> Self {
+        Self {
+            backlog: backlog(),
+            poolsize: poolsize(),
+        }
+    }
+}
diff --git a/rust/ccommon-derive/CMakeLists.txt b/rust/ccommon-derive/CMakeLists.txt
new file mode 100644
index 000000000..590e98afd
--- /dev/null
+++ b/rust/ccommon-derive/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-derive)
diff --git a/rust/ccommon-derive/Cargo.toml b/rust/ccommon-derive/Cargo.toml
new file mode 100644
index 000000000..c9616d41f
--- /dev/null
+++ b/rust/ccommon-derive/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "ccommon-derive"
+version = "0.1.0"
+authors = ["Sean Lynch <slynch@twitter.com>"]
+edition = "2018"
+publish = false
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "1.0.0", features = [ "parsing" ] }
+quote = "1.0.0"
+proc-macro2 = "1.0.0"
+proc-macro-crate = "0.1.4"
diff --git a/rust/ccommon-derive/src/attrs.rs b/rust/ccommon-derive/src/attrs.rs
new file mode 100644
index 000000000..34e6503f6
--- /dev/null
+++ b/rust/ccommon-derive/src/attrs.rs
@@ -0,0 +1,191 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::parse::*;
+use syn::punctuated::*;
+use syn::spanned::Spanned;
+use syn::*;
+
+use std::mem;
+
+pub struct AttrOption<T> {
+    pub name: Ident,
+    pub eq: Token![=],
+    pub val: T,
+}
+
+pub type EqOption = AttrOption<Lit>;
+pub type ExprOption = AttrOption<Expr>;
+
+pub struct MetricAttr {
+    pub desc: EqOption,
+    pub name: Option<EqOption>,
+}
+
+pub struct OptionAttr {
+    pub desc: EqOption,
+    pub name: Option<EqOption>,
+    pub default: Option<ExprOption>,
+}
+
+enum StrOrExpr {
+    Str(LitStr),
+    Expr(Expr),
+}
+
+impl Parse for StrOrExpr {
+    fn parse(buf: &ParseBuffer) -> Result<Self> {
+        if buf.fork().parse::<LitStr>().is_ok() {
+            return Ok(StrOrExpr::Str(buf.parse()?));
+        }
+
+        buf.parse().map(StrOrExpr::Expr)
+    }
+}
+
+impl AttrOption<StrOrExpr> {
+    pub fn into_lit(self) -> Result<EqOption> {
+        match self.val {
+            StrOrExpr::Str(s) => Ok(EqOption {
+                name: self.name,
+                eq: self.eq,
+                val: Lit::Str(s),
+            }),
+            StrOrExpr::Expr(e) => Err(Error::new(
+                e.span(),
+                "Found expression, expected a literal string",
+            )),
+        }
+    }
+
+    pub fn into_expr(self) -> ExprOption {
+        let expr = match self.val {
+            StrOrExpr::Str(s) => parse_quote!(#s),
+            StrOrExpr::Expr(e) => e,
+        };
+
+        ExprOption {
+            name: self.name,
+            eq: self.eq,
+            val: expr,
+        }
+    }
+}
+
+impl<T: Parse> Parse for AttrOption<T> {
+    fn parse(buf: &ParseBuffer) -> Result<Self> {
+        Ok(Self {
+            name: buf.parse()?,
+            eq: buf.parse()?,
+            val: buf.parse()?,
+        })
+    }
+}
+
+impl Parse for MetricAttr {
+    fn parse(buf: &ParseBuffer) -> Result<Self> {
+        let seq: Punctuated<EqOption, Token![,]> = Punctuated::parse_terminated(buf)?;
+
+        let mut desc = None;
+        let mut name = None;
+
+        for opt in seq {
+            let span = opt.name.span();
+            let param = opt.name.to_string();
+            let seen = match &*param {
+                "desc" => mem::replace(&mut desc, Some(opt)).is_some(),
+                "name" => mem::replace(&mut name, Some(opt)).is_some(),
+                _ => {
+                    return Err(Error::new(
+                        opt.name.span(),
+                        format!("Unknown option `{}`", opt.name),
+                    ))
+                }
+            };
+
+            if seen {
+                return Err(Error::new(
+                    span,
+                    format!("`{}` may only be specified once", param),
+                ));
+            }
+        }
+
+        let desc = match desc {
+            Some(x) => x,
+            None => return Err(buf.error("Expected a `desc` parameter here")),
+        };
+
+        Ok(Self { desc, name })
+    }
+}
+
+impl Parse for OptionAttr {
+    fn parse(buf: &ParseBuffer) -> Result<Self> {
+        let seq: Punctuated<AttrOption<StrOrExpr>, Token![,]> = Punctuated::parse_terminated(buf)?;
+
+        let mut desc = None;
+        let mut name = None;
+        let mut default = None;
+
+        for val in seq {
+            let span = val.span();
+            let param = val.name.to_string();
+            let seen = match &*param {
+                "desc" => mem::replace(&mut desc, Some(val.into_lit()?)).is_some(),
+                "name" => mem::replace(&mut name, Some(val.into_lit()?)).is_some(),
+                "default" => mem::replace(&mut default, Some(val.into_expr())).is_some(),
+                _ => return Err(Error::new(span, format!("Unknown option `{}`", param))),
+            };
+
+            if seen {
+                return Err(Error::new(
+                    span,
+                    format!("`{}` may only be specified once", param),
+                ));
+            }
+        }
+
+        let desc = match desc {
+            Some(x) => x,
+            None => return Err(buf.error("Expected a `desc` parameter here")),
+        };
+
+        Ok(Self {
+            desc,
+            name,
+            default,
+        })
+    }
+}
+
+impl<T: ToTokens> ToTokens for AttrOption<T> {
+    fn to_tokens(&self, stream: &mut TokenStream) {
+        self.name.to_tokens(stream);
+        self.eq.to_tokens(stream);
+        self.val.to_tokens(stream);
+    }
+}
+
+impl ToTokens for StrOrExpr {
+    fn to_tokens(&self, stream: &mut TokenStream) {
+        match self {
+            Self::Str(s) => s.to_tokens(stream),
+            Self::Expr(e) => e.to_tokens(stream),
+        }
+    }
+}
diff --git a/rust/ccommon-derive/src/lib.rs b/rust/ccommon-derive/src/lib.rs
new file mode 100644
index 000000000..7aae4650e
--- /dev/null
+++ b/rust/ccommon-derive/src/lib.rs
@@ -0,0 +1,488 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Derive macros for `ccommon_rs`
+
+extern crate proc_macro;
+
+mod attrs;
+
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
+use syn::{
+    parse_macro_input, Attribute, Data, DeriveInput, Error, Field, Fields, Generics, Ident, Lit,
+    LitStr,
+};
+
+use self::attrs::*;
+
+/// Derive macro for `Metrics`.
+///
+/// Fields in the struct attempting to use this derive macro
+/// must either implement `SingleMetric` or `Metrics`. This is
+/// decided upon based on the field being decorated with the
+/// `metric` attribute.
+///
+/// # Example
+/// ```rust,ignore
+/// #[derive(Metrics)]
+/// struct MyMetrics {
+///     // This metric will have a name of `metric1` and a description
+///     // of `"The first metric"`.
+///     // This field requires that `Gauge` implements `SingleMetric`.
+///     #[metric(desc = "The first metric")]
+///     metric1: Gauge,
+///     
+///     // This metric will have a name of `mymetric.metric2` and a
+///     // a description of `"The second metric"`.
+///     // This field requires that `Counter` implements `SingleMetric`.
+///     #[metric(desc = "The second metric", "mymetric.metric2")]
+///     metric2: Counter
+/// }
+///
+/// #[derive(Metrics)]
+/// struct OtherMetrics {
+///     // This field must implement `Metrics`
+///     my_metrics: MyMetrics
+/// }
+/// ```
+#[proc_macro_derive(Metrics, attributes(metric))]
+pub fn derive_metrics(stream: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(stream as DeriveInput);
+
+    match derive_metrics_impl(input) {
+        Ok(x) => x,
+        Err(e) => e.to_compile_error(),
+    }
+    .into()
+}
+
+/// Derive macro for `Options`.
+///
+/// Fields in the struct attempting to use this derive macro
+/// must either implement `SingleOption` or `Options`. Which
+/// one of these will be required is decided by whether the
+/// field is decorated by the `option` attribute.
+///
+/// The following parameters can be passed to the `option` attribute
+/// - `desc`: Sets the description of the field.
+/// - `name`: Overrides the name of the field, the default
+///     name is the name of the field within the struct.
+/// - `default`: Override the default value for the field.
+///     By default, this is `Default::default()` or `std::ptr::null_mut()`
+///     in the case of strings. This can be any valid rust expression
+///     that returns the correct type.
+///
+/// # Example
+/// ```rust,ignore
+/// #[derive(Options)]
+/// #[repr(C)]
+/// struct MyOptions {
+///     // This option will have a name of `options.option1`, a description
+///     // of `Option 1`, and a default value of `false`.
+///     #[option(desc = "Option 1", name = "options.option1")]
+///     opt1: Bool,
+///
+///     #[option(
+///         desc = "Function result option",
+///         default = example_factory_function()
+///     )]
+///     opt2: UInt
+/// }
+///
+/// #[derive(Option)]
+/// #[repr(transparent)]
+/// struct OtherOptions {
+///     inner: MyOptions
+/// }
+/// ```
+#[proc_macro_derive(Options, attributes(option))]
+pub fn derive_options(stream: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(stream as DeriveInput);
+
+    match derive_options_impl(input) {
+        Ok(x) => x,
+        Err(e) => e.to_compile_error(),
+    }
+    .into()
+}
+
+fn derive_metrics_impl(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
+    let krate = crate_name("ccommon-rs")?;
+
+    let data = match input.data {
+        Data::Struct(data) => data,
+        Data::Enum(data) => {
+            return Err(Error::new(
+                data.enum_token.span(),
+                "Can only derive Metrics for a struct",
+            ))
+        }
+        Data::Union(data) => {
+            return Err(Error::new(
+                data.union_token.span(),
+                "Can only derive Metrics for a struct",
+            ))
+        }
+    };
+
+    if !is_repr_c_or_transparent(&input.attrs) {
+        return Err(Error::new(
+            input.ident.span(),
+            format!(
+                "`{}` must be either #[repr(C)] or #[repr(transparent)] to implement Metrics",
+                input.ident
+            ),
+        ));
+    }
+
+    if has_generics(&input.generics) {
+        return Err(Error::new(
+            input.generics.span(),
+            "Cannot derive Metrics for a struct with generics",
+        ));
+    }
+
+    let ident = input.ident;
+    let process_field = |is_tuple| {
+        let krate = krate.clone();
+        move |(i, field): (usize, &Field)| {
+            let ty = &field.ty;
+            let name = &field.ident;
+            let label = if is_tuple {
+                quote! {}
+            } else {
+                quote! { #name: }
+            };
+
+            Ok(match get_metric_attr(&field.attrs)? {
+                Some(attr) => {
+                    let desc = to_c_str(&attr.desc.val);
+                    let namestr = match attr.name {
+                        Some(name) => to_c_str(&name.val),
+                        None => match field.ident.as_ref() {
+                            Some(name) => to_c_str(&name_as_lit(name)),
+                            None => {
+                                to_c_str(&Lit::Str(LitStr::new(&format!("{}", i), field.span())))
+                            }
+                        },
+                    };
+
+                    quote! {
+                        #label <#ty as #krate::metric::SingleMetric>::new(#namestr, #desc)
+                    }
+                }
+                None => quote! {
+                    #label <#ty as #krate::metric::Metrics>::new()
+                },
+            })
+        }
+    };
+
+    let initializer = match data.fields {
+        Fields::Named(fields) => {
+            let initializers: Vec<_> = fields
+                .named
+                .iter()
+                .enumerate()
+                .map(process_field(false))
+                .collect::<Result<_, Error>>()?;
+
+            quote! {
+                Self {
+                    #( #initializers, )*
+                }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let initializers: Vec<_> = fields
+                .unnamed
+                .iter()
+                .enumerate()
+                .map(process_field(true))
+                .collect::<Result<_, Error>>()?;
+
+            quote! {
+                Self (
+                    #( #initializers, )*
+                )
+            }
+        }
+        Fields::Unit => quote!(Self),
+    };
+
+    Ok(quote! {
+        unsafe impl #krate::metric::Metrics for #ident {
+            fn new() -> Self {
+                #initializer
+            }
+        }
+    })
+}
+
+fn derive_options_impl(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
+    let krate = crate_name("ccommon-rs")?;
+
+    let data = match input.data {
+        Data::Struct(data) => data,
+        Data::Enum(data) => {
+            return Err(Error::new(
+                data.enum_token.span(),
+                "Can only derive Metrics for a struct",
+            ))
+        }
+        Data::Union(data) => {
+            return Err(Error::new(
+                data.union_token.span(),
+                "Can only derive Metrics for a struct",
+            ))
+        }
+    };
+
+    if !is_repr_c_or_transparent(&input.attrs) {
+        return Err(Error::new(
+            input.ident.span(),
+            format!(
+                "`{}` must be either #[repr(C)] or #[repr(transparent)] to implement Metrics",
+                input.ident
+            ),
+        ));
+    }
+
+    if has_generics(&input.generics) {
+        return Err(Error::new(
+            input.generics.span(),
+            "Cannot derive Metrics for a struct with generics",
+        ));
+    }
+
+    let ident = input.ident;
+    let process_field = |is_tuple| {
+        let krate = krate.clone();
+        move |(i, field): (usize, &Field)| {
+            let ty = &field.ty;
+            let name = &field.ident;
+            let label = if is_tuple {
+                quote! {}
+            } else {
+                quote! { #name: }
+            };
+
+            Ok(match get_option_attr(&field.attrs)? {
+                Some(attr) => {
+                    let desc = to_c_str(&attr.desc.val);
+                    let namestr = match attr.name {
+                        Some(name) => to_c_str(&name.val),
+                        None => match field.ident.as_ref() {
+                            Some(name) => to_c_str(&name_as_lit(name)),
+                            None => {
+                                to_c_str(&Lit::Str(LitStr::new(&format!("{}", i), field.span())))
+                            }
+                        },
+                    };
+
+                    match attr.default.map(|x| x.val) {
+                        Some(default) => quote! {
+                            #label <#ty as #krate::option::SingleOption>::new(
+                                #default,
+                                #namestr,
+                                #desc
+                            )
+                        },
+                        None => quote! {
+                            #label <#ty as #krate::option::SingleOption>::defaulted(#namestr, #desc)
+                        },
+                    }
+                }
+                None => quote! {
+                    #label <#ty as #krate::option::Options>::new()
+                },
+            })
+        }
+    };
+
+    let initializer = match data.fields {
+        Fields::Named(fields) => {
+            let initializers: Vec<_> = fields
+                .named
+                .iter()
+                .enumerate()
+                .map(process_field(false))
+                .collect::<Result<_, Error>>()?;
+
+            quote! {
+                Self { #( #initializers, )* }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let initializers: Vec<_> = fields
+                .unnamed
+                .iter()
+                .enumerate()
+                .map(process_field(true))
+                .collect::<Result<_, Error>>()?;
+
+            quote! {
+                Self ( #( #initializers, )* )
+            }
+        }
+        Fields::Unit => quote!(Self),
+    };
+
+    Ok(quote! {
+        unsafe impl #krate::option::Options for #ident {
+            fn new() -> Self {
+                #initializer
+            }
+        }
+    })
+}
+
+fn crate_name(name: &'static str) -> Result<TokenStream, Error> {
+    if std::env::var("CARGO_PKG_NAME").unwrap() == "ccommon-rs" {
+        return Ok(quote! { ::ccommon_rs });
+    }
+
+    let name = match proc_macro_crate::crate_name(name) {
+        Ok(name) => name,
+        Err(e) => return Err(Error::new(Span::call_site(), e)),
+    };
+
+    let ident = Ident::new(&name, Span::call_site());
+
+    Ok(quote! { ::#ident })
+}
+
+fn name_as_lit(name: &Ident) -> Lit {
+    Lit::Str(LitStr::new(&format!("{}", name), name.span()))
+}
+
+fn to_c_str(desc: &Lit) -> TokenStream {
+    use syn::LitByteStr;
+
+    let span = desc.span();
+
+    let mut value = match desc {
+        Lit::Str(lit) => lit.value().into_bytes(),
+        Lit::ByteStr(lit) => lit.value(),
+        _ => unreachable!(),
+    };
+
+    for &byte in &value {
+        if byte == b'\0' {
+            return quote_spanned! { span =>
+                compile_error!(
+                    "Description contained a nul character"
+                )
+            };
+        }
+    }
+
+    value.push(b'\0');
+
+    let lit = LitByteStr::new(&value, span);
+
+    quote! {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(#lit)
+        }
+    }
+}
+
+fn get_metric_attr(attrs: &[Attribute]) -> Result<Option<MetricAttr>, Error> {
+    for attr in attrs {
+        let ident = match attr.path.get_ident() {
+            Some(x) => x,
+            None => continue,
+        };
+
+        if ident != "metric" {
+            continue;
+        }
+
+        return Ok(Some(attr.parse_args()?));
+    }
+
+    Ok(None)
+}
+
+fn get_option_attr(attrs: &[Attribute]) -> Result<Option<OptionAttr>, Error> {
+    for attr in attrs {
+        let ident = match attr.path.get_ident() {
+            Some(x) => x,
+            None => continue,
+        };
+
+        if ident != "option" {
+            continue;
+        }
+
+        return Ok(Some(attr.parse_args()?));
+    }
+
+    Ok(None)
+}
+
+fn is_repr_c_or_transparent(attrs: &[Attribute]) -> bool {
+    use syn::{Meta, NestedMeta};
+
+    fn is_correct_meta(nested: &NestedMeta) -> bool {
+        let meta = match nested {
+            NestedMeta::Meta(meta) => meta,
+            _ => return false,
+        };
+
+        let path = match meta {
+            Meta::Path(path) => path,
+            _ => return false,
+        };
+
+        let ident = match path.get_ident() {
+            Some(ident) => ident,
+            _ => return false,
+        };
+
+        ident == "C" || ident == "transparent"
+    }
+
+    for attr in attrs {
+        let ident = match attr.path.get_ident() {
+            Some(ident) => ident,
+            None => continue,
+        };
+
+        if ident != "repr" {
+            continue;
+        }
+
+        let list = match attr.parse_meta() {
+            Ok(Meta::List(list)) => list,
+            _ => continue,
+        };
+
+        for nested in &list.nested {
+            if is_correct_meta(nested) {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn has_generics(generics: &Generics) -> bool {
+    generics.lt_token.is_some() || generics.where_clause.is_some()
+}
diff --git a/rust/ccommon-log/CMakeLists.txt b/rust/ccommon-log/CMakeLists.txt
new file mode 100644
index 000000000..b1495ec15
--- /dev/null
+++ b/rust/ccommon-log/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-log)
diff --git a/rust/ccommon-log/Cargo.toml b/rust/ccommon-log/Cargo.toml
new file mode 100644
index 000000000..2aa19dcad
--- /dev/null
+++ b/rust/ccommon-log/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "ccommon-log"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
+
diff --git a/rust/ccommon-log/src/lib.rs b/rust/ccommon-log/src/lib.rs
new file mode 100644
index 000000000..d2bf804ba
--- /dev/null
+++ b/rust/ccommon-log/src/lib.rs
@@ -0,0 +1,62 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const DEBUG_LOG_LEVEL: usize = 4;
+const DEBUG_LOG_FILE: Option<String> = None;
+const DEBUG_LOG_NBUF: usize = 0;
+
+// helper functions
+fn log_level() -> usize {
+    DEBUG_LOG_LEVEL
+}
+
+fn log_file() -> Option<String> {
+    DEBUG_LOG_FILE
+}
+
+fn log_nbuf() -> usize {
+    DEBUG_LOG_NBUF
+}
+
+// struct definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct DebugConfig {
+    #[cfg_attr(feature = "serde", serde(default = "log_level"))]
+    log_level: usize,
+    #[cfg_attr(feature = "serde", serde(default = "log_file"))]
+    log_file: Option<String>,
+    #[cfg_attr(feature = "serde", serde(default = "log_nbuf"))]
+    log_nbuf: usize,
+}
+
+// implementation
+impl DebugConfig {
+    pub fn log_level(&self) -> usize {
+        self.log_level
+    }
+
+    pub fn log_file(&self) -> Option<String> {
+        self.log_file.clone()
+    }
+
+    pub fn log_nbuf(&self) -> usize {
+        self.log_nbuf
+    }
+}
+
+// trait implementations
+impl Default for DebugConfig {
+    fn default() -> Self {
+        Self {
+            log_level: log_level(),
+            log_file: log_file(),
+            log_nbuf: log_nbuf(),
+        }
+    }
+}
diff --git a/rust/ccommon-rs/CMakeLists.txt b/rust/ccommon-rs/CMakeLists.txt
new file mode 100644
index 000000000..7d85faded
--- /dev/null
+++ b/rust/ccommon-rs/CMakeLists.txt
@@ -0,0 +1,9 @@
+file(WRITE CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}\n")
+
+cargo_build(NAME ccommon-rs)
+
+add_dependencies(ccommon-rs ccommon-sys)
+add_dependencies(ccommon-rs ccommon-derive)
+add_dependencies(ccommon-rs ccommon-backend)
+
+target_link_libraries(ccommon-rs INTERFACE ccommon-sys ccommon-derive)
diff --git a/rust/ccommon-rs/Cargo.toml b/rust/ccommon-rs/Cargo.toml
new file mode 100644
index 000000000..836ae1526
--- /dev/null
+++ b/rust/ccommon-rs/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "ccommon-rs"
+version = "0.1.0"
+authors = [
+	"Jonathan Simms <jsimms@twitter.com>",
+	"Sean Lynch <slynch@twitter.com>"
+]
+edition = "2018"
+
+[features]
+default = [ "derive" ]
+derive = [ "ccommon-derive" ]
+
+[dependencies]
+ccommon-sys = { path = "../ccommon-sys" }
+ccommon-backend = { path = "../ccommon-backend" }
+libc = "0.2.0"
+log = "0.4.0"
+bytes = "0.5.0"
+
+[dependencies.ccommon-derive]
+path = "../ccommon-derive"
+optional = true
+
+[build-dependencies]
+autocfg = "0.1.7"
+
+[dev-dependencies]
+rusty-fork = "0.2.0"
+gag = "0.1.10"
diff --git a/rust/ccommon-rs/build.rs b/rust/ccommon-rs/build.rs
new file mode 100644
index 000000000..0433a3c10
--- /dev/null
+++ b/rust/ccommon-rs/build.rs
@@ -0,0 +1,23 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use autocfg::AutoCfg;
+
+fn main() {
+    let cfg = AutoCfg::new().unwrap();
+
+    // For rust versions >= 1.38 we can use std::any::type_name
+    cfg.emit_rustc_version(1, 38);
+}
diff --git a/rust/ccommon_rs/src/bstring.rs b/rust/ccommon-rs/src/bstring.rs
similarity index 84%
rename from rust/ccommon_rs/src/bstring.rs
rename to rust/ccommon-rs/src/bstring.rs
index f8588d608..8c70b669e 100644
--- a/rust/ccommon_rs/src/bstring.rs
+++ b/rust/ccommon-rs/src/bstring.rs
@@ -1,3 +1,18 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 //! BString is a wrapper around a foreign allocated and freed pointer to a cc_bstring.
 //! It takes care of creating and freeing the foreign pointer within the normal
 //! Rust lifetime rules. It has a companion reference object BStr, and the relation
@@ -22,8 +37,8 @@
 //!
 //! [nasal demons]: http://www.catb.org/jargon/html/N/nasal-demons.html
 
-use cc_binding as bind;
 use std::borrow::Borrow;
+use std::borrow::BorrowMut;
 use std::boxed::Box;
 use std::cell::UnsafeCell;
 use std::fmt;
@@ -32,32 +47,22 @@ use std::fmt::Formatter;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::slice;
-use std::str;
-use std::borrow::BorrowMut;
-
-
-pub type CCbstring = bind::bstring;
+use std::str::{self, Utf8Error};
 
+pub type CCbstring = ccommon_sys::bstring;
 
 #[doc(hidden)]
 #[inline]
 unsafe fn raw_ptr_to_bytes<'a>(ptr: *const CCbstring) -> &'a [u8] {
-    slice::from_raw_parts(
-        (*ptr).data as *const _ as *const u8,
-        (*ptr).len as usize
-    )
+    slice::from_raw_parts((*ptr).data as *const _ as *const u8, (*ptr).len as usize)
 }
 
 #[doc(hidden)]
 #[inline]
 unsafe fn raw_ptr_to_bytes_mut<'a>(ptr: *mut CCbstring) -> &'a mut [u8] {
-    slice::from_raw_parts_mut(
-        (*ptr).data as *mut _ as *mut u8,
-        (*ptr).len as usize
-    )
+    slice::from_raw_parts_mut((*ptr).data as *mut _ as *mut u8, (*ptr).len as usize)
 }
 
-
 // this pattern lifted from https://docs.rs/foreign-types-shared/0.1.1/src/foreign_types_shared/lib.rs.html
 struct Opaque(UnsafeCell<()>);
 
@@ -91,6 +96,18 @@ impl BStr {
     pub fn as_ptr(&self) -> *mut CCbstring {
         self as *const _ as *mut _
     }
+
+    pub fn from_ref(ccb: &CCbstring) -> &Self {
+        unsafe { Self::from_ptr(ccb as *const CCbstring as *mut _) }
+    }
+
+    pub fn to_utf8_str(&self) -> Result<&str, Utf8Error> {
+        str::from_utf8(&self[..])
+    }
+
+    pub fn to_utf8_string(&self) -> Result<String, Utf8Error> {
+        self.to_utf8_str().map(|x| x.to_owned())
+    }
 }
 
 impl Deref for BStr {
@@ -117,7 +134,7 @@ impl AsRef<CCbstring> for BStr {
 
 impl AsMut<CCbstring> for BStr {
     fn as_mut(&mut self) -> &mut CCbstring {
-        unsafe { &mut *(self.as_ptr() as *mut _)}
+        unsafe { &mut *(self.as_ptr() as *mut _) }
     }
 }
 
@@ -129,7 +146,7 @@ impl Borrow<CCbstring> for BStr {
 
 impl BorrowMut<CCbstring> for BStr {
     fn borrow_mut(&mut self) -> &mut CCbstring {
-        unsafe { &mut *(self.as_ptr() as *mut _)}
+        unsafe { &mut *(self.as_ptr() as *mut _) }
     }
 }
 
@@ -227,7 +244,7 @@ pub struct BString(*mut CCbstring);
 
 impl BString {
     pub fn new(size: u32) -> Self {
-        let bsp: *mut CCbstring = unsafe { bind::bstring_alloc(size) };
+        let bsp: *mut CCbstring = unsafe { ccommon_sys::bstring_alloc(size) };
 
         assert!(!bsp.is_null());
         BString(bsp)
@@ -249,7 +266,7 @@ impl BString {
     /// Takes byte slice `&[u8]` and copies it into an owned BString.
     #[inline]
     pub fn from_bytes(s: &[u8]) -> Self {
-        let bsp: *mut CCbstring = unsafe { bind::bstring_alloc(s.len() as u32) };
+        let bsp: *mut CCbstring = unsafe { ccommon_sys::bstring_alloc(s.len() as u32) };
 
         assert!(!bsp.is_null());
 
@@ -264,6 +281,7 @@ impl BString {
     ///
     /// This method will panic if `src.len() != self.len()`
     #[inline]
+    // Note: Used for tests
     #[allow(dead_code)]
     fn copy_from_slice(&mut self, src: &[u8]) {
         assert_eq!(src.len(), self.len());
@@ -271,12 +289,12 @@ impl BString {
     }
 
     #[inline]
-    fn as_bytes(&self) -> &[u8] {
+    pub fn as_bytes(&self) -> &[u8] {
         unsafe { raw_ptr_to_bytes(self.0) }
     }
 
     #[inline]
-    fn as_bytes_mut(&mut self) -> &mut [u8] {
+    pub fn as_bytes_mut(&mut self) -> &mut [u8] {
         unsafe { raw_ptr_to_bytes_mut(self.0) }
     }
 
@@ -284,6 +302,14 @@ impl BString {
     fn len(&self) -> usize {
         unsafe { (*self.0).len as usize }
     }
+
+    pub fn to_utf8_str(&self) -> Result<&str, Utf8Error> {
+        str::from_utf8(self.as_bytes())
+    }
+
+    pub fn to_utf8_string(&self) -> Result<String, Utf8Error> {
+        self.to_utf8_str().map(|x| x.to_owned())
+    }
 }
 
 impl Debug for BString {
@@ -305,7 +331,7 @@ impl PartialEq for BString {
 impl Drop for BString {
     #[inline]
     fn drop(&mut self) {
-        unsafe { bind::bstring_free(&mut self.0) };
+        unsafe { ccommon_sys::bstring_free(&mut self.0) };
     }
 }
 
@@ -386,7 +412,6 @@ impl<'a> From<&'a str> for BString {
 unsafe impl Send for BString {}
 unsafe impl Sync for BString {}
 
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -395,14 +420,16 @@ mod test {
     fn test_raw_ptr_to_bytes() {
         let bs = CCbstring {
             len: 5,
-            data: String::from("abcde").as_ptr() as *mut i8
+            data: "abcde".as_ptr() as *mut i8,
         };
 
         let ptr: *const CCbstring = &bs as *const CCbstring;
 
         let slice = unsafe { raw_ptr_to_bytes(ptr) };
+
+        assert_eq!(slice.as_ptr(), bs.data as *mut u8);
         assert_eq!(slice.len(), 5);
-        assert_eq!(&slice[..], "abcde".as_bytes());
+        assert_eq!(slice, "abcde".as_bytes());
     }
 
     #[test]
@@ -450,7 +477,7 @@ mod test {
     }
 
     fn foreign_code(s: &str) -> *mut CCbstring {
-       BString::into_raw(BString::from(s))
+        BString::into_raw(BString::from(s))
     }
 
     #[test]
diff --git a/rust/ccommon-rs/src/buf.rs b/rust/ccommon-rs/src/buf.rs
new file mode 100644
index 000000000..613589447
--- /dev/null
+++ b/rust/ccommon-rs/src/buf.rs
@@ -0,0 +1,366 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use ccommon_sys::buf;
+
+use std::io::{self, Read, Write};
+use std::mem::MaybeUninit;
+use std::ops::{Deref, DerefMut};
+
+use bytes::{Buf as BytesBuf, BufMut as BytesBufMut};
+
+/// A non-owned buffer, can be read from and written to.
+///
+/// # Safety
+/// This is a self-referential struct that assumes it is
+/// followed by it's data. Attempting to move it or create
+/// a new instance (via transmute) will cause UB.
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct Buf {
+    buf: buf,
+}
+
+impl Buf {
+    pub unsafe fn from_ptr<'a>(buf: *const buf) -> &'a Buf {
+        &*(buf as *const Buf)
+    }
+
+    pub unsafe fn from_mut_ptr<'a>(buf: *mut buf) -> &'a mut Buf {
+        &mut *(buf as *mut Buf)
+    }
+
+    pub fn as_ptr(&self) -> *const buf {
+        &self.buf as *const buf
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut buf {
+        &mut self.buf as *mut buf
+    }
+
+    #[deprecated(note = "use from_ptr instead")]
+    pub unsafe fn from_raw<'a>(buf: *const buf) -> &'a Buf {
+        &*(buf as *const Buf)
+    }
+
+    #[deprecated(note = "use from_mut_ptr instead")]
+    pub unsafe fn from_raw_mut<'a>(buf: *mut buf) -> &'a mut Buf {
+        &mut *(buf as *mut Buf)
+    }
+
+    #[deprecated(note = "use as_ptr instead")]
+    #[allow(clippy::wrong_self_convention)]
+    pub fn into_raw(&self) -> *const buf {
+        &self.buf as *const _
+    }
+
+    #[deprecated(note = "use as_mut_ptr instead")]
+    #[allow(clippy::wrong_self_convention)]
+    pub fn into_raw_mut(&mut self) -> *mut buf {
+        &mut self.buf as *mut _
+    }
+
+    /// The number of bytes that can still be written to the
+    /// buffer before it is full.
+    pub fn write_size(&self) -> usize {
+        assert!(self.buf.wpos as usize <= self.buf.end as usize);
+
+        self.buf.end as usize - self.buf.wpos as usize
+    }
+
+    /// The number of bytes left to read from the buffer
+    pub fn read_size(&self) -> usize {
+        assert!(self.buf.rpos as usize <= self.buf.wpos as usize);
+
+        self.buf.wpos as usize - self.buf.rpos as usize
+    }
+
+    pub fn capacity(&self) -> usize {
+        assert!(self.buf.begin.as_ptr() as usize <= self.buf.end as usize);
+
+        self.buf.end as usize - self.buf.begin.as_ptr() as usize
+    }
+
+    /// Additional capacity required to write count bytes to the buffer
+    pub fn new_cap(&self, bytes: usize) -> usize {
+        assert!(self.buf.begin.as_ptr() as usize <= self.buf.wpos as usize);
+
+        bytes.saturating_sub(self.write_size())
+    }
+
+    /// Clear the buffer and remove it from any allocation pool
+    pub fn reset(&mut self) {
+        self.buf.next.stqe_next = std::ptr::null_mut();
+        self.buf.free = false;
+        self.buf.rpos = self.buf.begin.as_mut_ptr();
+        self.buf.wpos = self.buf.rpos;
+    }
+
+    /// Shift data in the buffer to the end of the buffer.
+    pub fn rshift(&mut self) {
+        let size = self.read_size();
+
+        if size > 0 {
+            unsafe {
+                std::ptr::copy(self.buf.rpos, self.buf.rpos.offset(-(size as isize)), size);
+            }
+        }
+
+        self.buf.rpos = unsafe { self.buf.end.offset(-(size as isize)) };
+        self.buf.wpos = self.buf.end;
+    }
+
+    /// Shift data in the buffer to the start of the buffer.
+    pub fn lshift(&mut self) {
+        let size = self.read_size();
+
+        if size > 0 {
+            unsafe {
+                std::ptr::copy(self.buf.rpos, self.buf.begin.as_mut_ptr(), size);
+            }
+        }
+
+        self.buf.rpos = self.buf.begin.as_mut_ptr();
+        self.buf.wpos = self.buf.rpos.wrapping_add(size);
+    }
+
+    /// Get the currently valid part of the buffer as a slice
+    pub fn as_slice(&self) -> &[u8] {
+        use std::slice;
+
+        unsafe { slice::from_raw_parts(self.buf.rpos as *const u8, self.read_size()) }
+    }
+
+    /// Get the currently valid part of the buffer as a slice
+    pub fn as_slice_mut(&mut self) -> &mut [u8] {
+        use std::slice;
+
+        unsafe { slice::from_raw_parts_mut(self.buf.rpos as *mut u8, self.read_size()) }
+    }
+}
+
+/// An owned buffer.
+///
+/// In addition to all the operations supported by `Buf`
+/// an `OwnedBuf` also supports some resizing operations.
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct OwnedBuf {
+    buf: *mut buf,
+}
+
+impl OwnedBuf {
+    pub unsafe fn from_raw(buf: *mut buf) -> Self {
+        Self { buf }
+    }
+
+    pub fn into_raw(self) -> *mut buf {
+        let buf = self.buf;
+        // Don't want to run drop on the destructor
+        std::mem::forget(self);
+        buf
+    }
+
+    pub fn as_ptr(&self) -> *const buf {
+        self.buf
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut buf {
+        self.buf
+    }
+
+    /// Double the size of the buffer.
+    pub fn double(&mut self) -> Result<(), crate::Error> {
+        use ccommon_sys::dbuf_double;
+
+        unsafe {
+            let status = dbuf_double(&mut self.buf as *mut _);
+
+            if status != 0 {
+                Err(status.into())
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    /// Shrink the buffer to the max of the initial size or the content size.
+    pub fn shrink(&mut self) -> Result<(), crate::Error> {
+        use ccommon_sys::dbuf_shrink;
+
+        unsafe {
+            let status = dbuf_shrink(&mut self.buf as *mut _);
+
+            if status != 0 {
+                Err(status.into())
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    /// Resize the buffer to fit the required capacity.
+    ///
+    /// # Panics
+    /// Panics if `cap` is greater than `u32::MAX`.
+    pub fn fit(&mut self, cap: usize) -> Result<(), crate::Error> {
+        use ccommon_sys::dbuf_fit;
+
+        assert!((cap as u64) <= std::u32::MAX as u64);
+
+        unsafe {
+            let status = dbuf_fit(&mut self.buf as *mut _, cap as u32);
+
+            if status != 0 {
+                Err(status.into())
+            } else {
+                Ok(())
+            }
+        }
+    }
+}
+
+unsafe impl Send for OwnedBuf {}
+unsafe impl Sync for OwnedBuf {}
+
+impl Drop for OwnedBuf {
+    fn drop(&mut self) {
+        use ccommon_sys::buf_destroy;
+
+        unsafe {
+            buf_destroy(&mut self.buf as *mut _);
+        }
+    }
+}
+
+impl Deref for OwnedBuf {
+    type Target = Buf;
+
+    fn deref(&self) -> &Buf {
+        unsafe { Buf::from_ptr(self.buf) }
+    }
+}
+
+impl DerefMut for OwnedBuf {
+    fn deref_mut(&mut self) -> &mut Buf {
+        unsafe { Buf::from_mut_ptr(self.buf) }
+    }
+}
+
+impl Read for Buf {
+    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
+        let len = self.read_size().min(out.len());
+
+        unsafe { std::ptr::copy_nonoverlapping(self.buf.rpos as *const u8, out.as_mut_ptr(), len) }
+        self.buf.rpos = self.buf.rpos.wrapping_add(len);
+
+        Ok(len)
+    }
+}
+
+impl Write for Buf {
+    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
+        if src.is_empty() {
+            return Ok(0);
+        }
+
+        let len = self.write_size().min(src.len());
+
+        unsafe { std::ptr::copy_nonoverlapping(src.as_ptr(), self.buf.wpos as *mut _, src.len()) }
+        self.buf.wpos = self.buf.wpos.wrapping_add(len);
+
+        Ok(len)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Read for OwnedBuf {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (**self).read(buf)
+    }
+}
+
+impl Write for OwnedBuf {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (**self).write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        (**self).flush()
+    }
+}
+
+impl BytesBuf for Buf {
+    fn remaining(&self) -> usize {
+        self.read_size()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        self.as_slice()
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        assert!(cnt <= self.read_size());
+        self.buf.rpos = self.buf.rpos.wrapping_add(cnt);
+    }
+}
+
+impl BytesBufMut for Buf {
+    fn remaining_mut(&self) -> usize {
+        self.write_size()
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        assert!(cnt <= self.write_size());
+        self.buf.wpos = self.buf.wpos.wrapping_add(cnt);
+    }
+
+    fn bytes_mut(&mut self) -> &mut [MaybeUninit<u8>] {
+        unsafe {
+            std::slice::from_raw_parts_mut(self.buf.wpos as *mut MaybeUninit<u8>, self.write_size())
+        }
+    }
+}
+
+impl BytesBuf for OwnedBuf {
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        BytesBuf::bytes(&**self)
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        (**self).advance(cnt)
+    }
+}
+
+impl BytesBufMut for OwnedBuf {
+    fn remaining_mut(&self) -> usize {
+        (**self).remaining_mut()
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        (**self).advance_mut(cnt)
+    }
+
+    fn bytes_mut(&mut self) -> &mut [MaybeUninit<u8>] {
+        BytesBufMut::bytes_mut(&mut **self)
+    }
+}
diff --git a/rust/ccommon-rs/src/ccbox.rs b/rust/ccommon-rs/src/ccbox.rs
new file mode 100644
index 000000000..10fe4e415
--- /dev/null
+++ b/rust/ccommon-rs/src/ccbox.rs
@@ -0,0 +1,222 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::convert::TryInto;
+use std::fmt;
+use std::mem::{self, MaybeUninit};
+use std::ops::*;
+use std::ptr::NonNull;
+
+use ccommon_sys::{_cc_alloc, _cc_free};
+
+use crate::error::AllocationError;
+
+macro_rules! c_str {
+    ($s:expr) => {
+        concat!($s, "\0").as_ptr() as *const i8
+    };
+}
+
+/// A box that allocates and frees using `cc_alloc`
+/// and `cc_free`.
+#[repr(transparent)]
+pub struct CCBox<T: ?Sized>(NonNull<T>);
+
+unsafe impl<T: Send + ?Sized> Send for CCBox<T> {}
+unsafe impl<T: Sync + ?Sized> Sync for CCBox<T> {}
+
+impl<T> CCBox<T> {
+    /// Create a new `CCBox` with `val` inside.
+    ///
+    /// # Panics
+    /// Panics if the underlying allocator fails to allocate
+    /// or if `T` requires an alignment of greater than 16.
+    pub fn new(val: T) -> CCBox<T> {
+        // Most malloc implementations give 16-byte alignment
+        assert!(mem::align_of::<T>() <= 16);
+
+        match Self::try_new(val) {
+            Ok(x) => x,
+            Err(e) => panic!("{}", e),
+        }
+    }
+
+    /// Attempt to create a new `CCBox` with `val` inside.
+    ///
+    /// Since the underlying allocator does not support
+    /// passing alignments, any allocation with alignment
+    /// greater than 16 will fail.
+    ///
+    /// In addition, returns an error whenever the underlying
+    /// allocator returns `NULL`.
+    pub fn try_new(val: T) -> Result<CCBox<T>, AllocationError<T>> {
+        if mem::size_of_val(&val) == 0 {
+            return Ok(CCBox(NonNull::dangling()));
+        }
+
+        if mem::align_of_val(&val) > 16 {
+            return Err(AllocationError::new());
+        }
+
+        unsafe {
+            let ptr = _cc_alloc(
+                mem::size_of_val(&val).try_into().unwrap(),
+                c_str!(module_path!()),
+                line!() as std::os::raw::c_int,
+            ) as *mut MaybeUninit<T>;
+
+            *ptr = MaybeUninit::new(val);
+
+            Ok(CCBox(match NonNull::new(ptr as *mut T) {
+                Some(x) => x,
+                None => return Err(AllocationError::new()),
+            }))
+        }
+    }
+}
+
+impl<T: ?Sized> CCBox<T> {
+    /// Construct a `CCBox` from a raw pointer.
+    ///
+    /// After this function is called the raw pointer is owned by
+    /// the resulting `CCBox`. When the box is dropped, it will run
+    /// the destructor for the stored value and free the pointer
+    /// using [`_cc_free`](ccommon_sys::_cc_free).
+    ///
+    /// # Safety
+    /// For this to be safe the pointer must have been allocated
+    /// using [`_cc_alloc`](ccommon_sys::_cc_alloc) (this includes
+    /// values allocated through `CCBox::new`).
+    pub unsafe fn from_raw(raw: *mut T) -> Self {
+        assert!(!raw.is_null());
+
+        CCBox(NonNull::new_unchecked(raw))
+    }
+
+    /// Consumes the box and returns the pointer stored inside.
+    ///
+    /// The pointer should be freed using [`_cc_free`](ccommon_sys::_cc_free)
+    /// or by recreating a `CCBox` from the pointer.
+    pub fn into_raw(b: Self) -> *mut T {
+        let ptr = b.0.as_ptr();
+        // Don't want to free the pointer
+        mem::forget(b);
+        ptr
+    }
+}
+
+impl<T: ?Sized> Drop for CCBox<T> {
+    fn drop(&mut self) {
+        use std::ptr;
+
+        if mem::size_of_val(&**self) != 0 {
+            unsafe {
+                ptr::drop_in_place(self.0.as_ptr());
+
+                _cc_free(
+                    self.0.as_ptr() as *mut std::ffi::c_void,
+                    c_str!(module_path!()),
+                    line!() as std::os::raw::c_int,
+                );
+            }
+        }
+    }
+}
+
+impl<T: ?Sized> Deref for CCBox<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { self.0.as_ref() }
+    }
+}
+
+impl<T: ?Sized> DerefMut for CCBox<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { self.0.as_mut() }
+    }
+}
+
+impl<T: Default> Default for CCBox<T> {
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
+impl<T: ?Sized> AsRef<T> for CCBox<T> {
+    fn as_ref(&self) -> &T {
+        &*self
+    }
+}
+
+impl<T: ?Sized> AsMut<T> for CCBox<T> {
+    fn as_mut(&mut self) -> &mut T {
+        &mut *self
+    }
+}
+
+impl<T: Clone> Clone for CCBox<T> {
+    fn clone(&self) -> Self {
+        CCBox::new(self.as_ref().clone())
+    }
+}
+
+impl<T: fmt::Debug + ?Sized> fmt::Debug for CCBox<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        (**self).fmt(fmt)
+    }
+}
+
+impl<T: fmt::Display + ?Sized> fmt::Display for CCBox<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        (**self).fmt(fmt)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ccbox_size_tests() {
+        use std::mem::size_of;
+
+        assert_eq!(size_of::<CCBox<()>>(), size_of::<*mut ()>());
+
+        assert_eq!(size_of::<Option<CCBox<()>>>(), size_of::<*mut ()>());
+    }
+
+    #[test]
+    fn ptr_round_trip() {
+        unsafe {
+            let ptr1 = _cc_alloc(16, c_str!("test"), 0);
+            let boxed = CCBox::from_raw(ptr1);
+            let ptr2 = CCBox::into_raw(boxed);
+
+            // Ensure the pointer is properly freed
+            let _boxed = CCBox::from_raw(ptr2);
+
+            assert_eq!(ptr1, ptr2);
+        }
+    }
+
+    #[test]
+    fn overaligned() {
+        #[repr(align(128))]
+        struct OverAligned(u8);
+
+        assert!(CCBox::try_new(OverAligned(0)).is_err());
+    }
+}
diff --git a/rust/ccommon-rs/src/error.rs b/rust/ccommon-rs/src/error.rs
new file mode 100644
index 000000000..25dd0da4a
--- /dev/null
+++ b/rust/ccommon-rs/src/error.rs
@@ -0,0 +1,108 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::error::Error as StdError;
+use std::fmt::{self, Debug, Display, Formatter};
+
+/// Error codes that could be returned by ccommon functions.
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub enum Error {
+    Generic = -1,
+    EAgain = -2,
+    ERetry = -3,
+    ENoMem = -4,
+    EEmpty = -5,
+    ERdHup = -6,
+    EInval = -7,
+    EOther = -8,
+}
+
+impl From<std::os::raw::c_int> for Error {
+    fn from(val: std::os::raw::c_int) -> Self {
+        match val {
+            -1 => Error::Generic,
+            -2 => Error::EAgain,
+            -3 => Error::ERetry,
+            -4 => Error::ENoMem,
+            -5 => Error::EEmpty,
+            -6 => Error::ERdHup,
+            -7 => Error::EInval,
+            _ => Error::EOther,
+        }
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        match self {
+            Error::Generic => write!(fmt, "Generic Error"),
+            Error::EAgain => write!(fmt, "EAGAIN"),
+            Error::ERetry => write!(fmt, "ERETRY"),
+            Error::ENoMem => write!(fmt, "ENOMEM"),
+            Error::EEmpty => write!(fmt, "EEMPTY"),
+            Error::ERdHup => write!(fmt, "ERDHUP"),
+            Error::EInval => write!(fmt, "EINVAL"),
+            Error::EOther => write!(fmt, "EOTHER"),
+        }
+    }
+}
+
+impl StdError for Error {}
+
+/// An allocation handler failed to allocate a value.
+///
+/// Converts to `Error::ENoMem`.
+pub struct AllocationError<T>(pub(crate) std::marker::PhantomData<T>);
+
+impl<T> AllocationError<T> {
+    pub(crate) fn new() -> Self {
+        AllocationError(std::marker::PhantomData)
+    }
+}
+
+impl<T> Display for AllocationError<T> {
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        #[cfg(rustc_1_38)]
+        let res = write!(
+            fmt,
+            "Unable to allocate a value of type {} with size {}",
+            std::any::type_name::<T>(),
+            std::mem::size_of::<T>()
+        );
+
+        #[cfg(not(rustc_1_38))]
+        let res = write!(
+            fmt,
+            "Unable to allocate a value of size {}",
+            std::mem::size_of::<T>()
+        );
+
+        res
+    }
+}
+impl<T> Debug for AllocationError<T> {
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        fmt.debug_struct("AllocationError").finish()
+    }
+}
+
+impl<T> StdError for AllocationError<T> {}
+
+impl<T> From<AllocationError<T>> for Error {
+    fn from(_: AllocationError<T>) -> Self {
+        Self::ENoMem
+    }
+}
diff --git a/rust/ccommon-rs/src/lib.rs b/rust/ccommon-rs/src/lib.rs
new file mode 100644
index 000000000..b32730b09
--- /dev/null
+++ b/rust/ccommon-rs/src/lib.rs
@@ -0,0 +1,32 @@
+// ccommon - a cache common library.
+// Copyright (C) 2018 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Needed to allow derive macros within this crate
+extern crate self as ccommon_rs;
+
+#[cfg(feature = "derive")]
+pub use ccommon_derive::{Metrics, Options};
+
+pub mod bstring;
+pub mod buf;
+pub mod log;
+pub mod metric;
+pub mod option;
+
+mod ccbox;
+mod error;
+
+pub use self::ccbox::CCBox;
+pub use self::error::{AllocationError, Error};
diff --git a/rust/ccommon-rs/src/log/debug.rs b/rust/ccommon-rs/src/log/debug.rs
new file mode 100644
index 000000000..1f9d31311
--- /dev/null
+++ b/rust/ccommon-rs/src/log/debug.rs
@@ -0,0 +1,121 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use ccommon_sys::{debug_options_st, debug_setup, debug_teardown};
+
+use crate::Error;
+
+static DEBUG_INIT: AtomicBool = AtomicBool::new(false);
+
+/// RAII Wrapper around the ccommon debug logger.
+///
+/// # Safety
+/// It is unsafe to call `debug_setup` or `debug_teardown`
+/// while an instance of DebugLogger exists.
+///
+/// If a debug logger has already been created using `debug_setup`
+/// then use [`from_existing`](#fn.from_existing) to create a
+/// `DebugLogger` instance wrapping it.
+pub struct DebugLogger(());
+
+impl DebugLogger {
+    /// Create a new debug logger.
+    ///
+    /// If another debug logger is currently active then
+    /// this will return `Error::EInval`, otherwise the
+    /// error status reflects the return code of `debug_setup`.
+    pub fn new<'a, I>(opts: I) -> Result<Self, Error>
+    where
+        I: Into<Option<&'a debug_options_st>>,
+    {
+        if DEBUG_INIT
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+            .is_err()
+        {
+            return Err(Error::EInval);
+        }
+
+        let opts = opts
+            .into()
+            .map(|x| x as *const _ as *mut _)
+            .unwrap_or(std::ptr::null_mut());
+
+        let status = unsafe { debug_setup(opts) };
+
+        if status < 0 {
+            Err(status.into())
+        } else {
+            Ok(Self(()))
+        }
+    }
+
+    /// Overwrite the current debug logger with a new one.
+    ///
+    /// # Safety
+    /// It is unsafe to call this method while logging is
+    /// happening concurrently.
+    pub unsafe fn overwrite<'a, I>(&self, opts: I) -> Result<Self, Error>
+    where
+        I: Into<Option<&'a debug_options_st>>,
+    {
+        let opts = opts
+            .into()
+            .map(|x| x as *const _ as *mut _)
+            .unwrap_or(std::ptr::null_mut());
+
+        let status = debug_setup(opts);
+
+        if status < 0 {
+            Err(status.into())
+        } else {
+            Ok(Self(()))
+        }
+    }
+
+    /// Create a debug logger from one that has already been
+    /// set up through `debug_setup` or via
+    /// [`release`](#fn.release).
+    ///
+    /// # Safety
+    /// It is unsafe to call this method while an existing
+    /// instance of `DebugLogger` is live.
+    pub unsafe fn from_existing() -> Self {
+        DEBUG_INIT.store(true, Ordering::Relaxed);
+
+        Self(())
+    }
+
+    /// Release the current global debug logger from the lifetime
+    /// of this particular `DebugLogger`.
+    ///
+    /// # Safety
+    /// It is unsafe to create a new debug logger before
+    /// `debug_teardown` is called.
+    pub unsafe fn release(self) {
+        std::mem::forget(self);
+        DEBUG_INIT.store(false, Ordering::Relaxed);
+    }
+}
+
+impl Drop for DebugLogger {
+    fn drop(&mut self) {
+        unsafe {
+            debug_teardown();
+            DEBUG_INIT.store(false, Ordering::Relaxed);
+        }
+    }
+}
diff --git a/rust/ccommon-rs/src/log/mod.rs b/rust/ccommon-rs/src/log/mod.rs
new file mode 100644
index 000000000..56f4bb2ad
--- /dev/null
+++ b/rust/ccommon-rs/src/log/mod.rs
@@ -0,0 +1,52 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Bindings related to logging.
+//!
+//! There are currently two parts to this module.
+//! 1. `DebugLogger`: A RAII wrapper around ccommon's debug module. It is
+//!    needed to set up the debug logging infrastructure that is used
+//!    as a backend by
+//! 2. The `log` shim. This is a logger that forwards the logging macros
+//!    provided by the [`log`](https://docs.rs/log) crate into the debug
+//!    logger initialized by part 1.
+//! 3. A panic handler which will utilize ccommon's logging infrastructure
+//!    in addition to printing out normal log messages.
+//!
+//! To use this module initialize the logging shim by calling [`init()`][0]
+//! (alternatively, use [`rust_log_setup`][1] and [`rust_log_teardown`][2] from
+//! C code). In addition, create an instance of [`DebugLogger`][3] (or
+//! initialize it from C code).
+//!
+//! Now, just use the log macros as normal and all logs will be run through
+//! ccommon's logging infrastructure.
+//!
+//! An optional extra thing that can be down is to use
+//! [`set_panic_handler`][4] to set a panic hook which
+//! will utilize common's logging infrastructure in addition to printing
+//! to stderr.
+//!
+//! [0]: ccommon_rs::log::init
+//! [1]: ccommon_rs::log::rust_log_setup
+//! [2]: ccommon_rs::log::rust_log_teardown
+//! [3]: ccommon_rs::log::DebugLogger
+//! [4]: ccommon_rs::log::set_panic_handler
+
+// Backend for the standard logging shim
+mod debug;
+mod shim;
+
+pub use self::debug::DebugLogger;
+pub use self::shim::{init, rust_log_setup, rust_log_teardown, set_panic_handler};
diff --git a/rust/ccommon-rs/src/log/shim.rs b/rust/ccommon-rs/src/log/shim.rs
new file mode 100644
index 000000000..ad284b221
--- /dev/null
+++ b/rust/ccommon-rs/src/log/shim.rs
@@ -0,0 +1,227 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::io::Write;
+use std::os::raw::{c_char, c_int};
+use std::panic::{self, PanicInfo};
+use std::sync::atomic::{AtomicPtr, Ordering};
+use std::thread;
+
+use ccommon_sys::{_log, debug_log_flush, debug_logger, LOG_MAX_LEN};
+use log::{Level, Log, Metadata, Record, SetLoggerError};
+
+fn ccommon_dlog() -> &'static AtomicPtr<debug_logger> {
+    unsafe { &*(&ccommon_sys::dlog as *const _ as *const AtomicPtr<debug_logger>) }
+}
+
+const FILENAME_MAX_LEN: usize = 1024;
+
+/// A log implementation which wraps the debug logger from ccommon
+struct CCLog;
+
+unsafe impl Send for CCLog {}
+
+unsafe impl Sync for CCLog {}
+
+fn level_to_int(level: Level) -> c_int {
+    use ccommon_sys::*;
+
+    let level = match level {
+        Level::Trace => LOG_VERB,
+        Level::Debug => LOG_DEBUG,
+        Level::Info => LOG_INFO,
+        Level::Warn => LOG_WARN,
+        Level::Error => LOG_ERROR,
+    };
+
+    level as c_int
+}
+
+impl CCLog {
+    fn enabled_ptr(metadata: &Metadata, ptr: *const debug_logger) -> bool {
+        if ptr.is_null() {
+            return false;
+        }
+
+        unsafe {
+            // Note: Assumes the level doesn't change concurrently
+            (*ptr).level >= level_to_int(metadata.level())
+        }
+    }
+}
+
+impl Log for CCLog {
+    #[inline]
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        Self::enabled_ptr(metadata, ccommon_dlog().load(Ordering::Relaxed))
+    }
+
+    fn log(&self, record: &Record) {
+        let ptr = ccommon_dlog().load(Ordering::Relaxed);
+
+        if !Self::enabled_ptr(record.metadata(), ptr) {
+            return;
+        }
+
+        // +1 bytes are trailing nul bytes
+        let mut buffer = [0; LOG_MAX_LEN as usize + 1];
+        let mut filename = [0; FILENAME_MAX_LEN + 1];
+
+        let _ = write!(&mut buffer[0..LOG_MAX_LEN as usize], "{}", record.args());
+
+        // Make a best-effort attempt to provide a meainingful
+        // location that is consistent with how ccommon does
+        // log messages.
+        let filestr = record
+            .file()
+            .or_else(|| record.module_path())
+            .unwrap_or_else(|| record.target());
+        let _ = write!(&mut filename[0..FILENAME_MAX_LEN], "{}", filestr);
+
+        unsafe {
+            _log(
+                ptr,
+                (&filename).as_ptr() as *const c_char,
+                record.line().map(|x| x as c_int).unwrap_or(-1),
+                level_to_int(record.level()),
+                "%s\0".as_ptr() as *const c_char,
+                (&buffer).as_ptr() as *const c_char,
+            )
+        }
+    }
+
+    fn flush(&self) {
+        unsafe {
+            // The argument here is unused and ccommon uses it for
+            // compatibility with other modules such as timer_wheel
+            debug_log_flush(std::ptr::null_mut());
+        }
+    }
+}
+
+// The logger has no state so a global zero-sized instance
+// works just fine.
+static LOGGER: CCLog = CCLog;
+
+/// Initialize the logger. It will automatically use the
+/// ccommon debug logger once that is set up.
+pub fn init() -> Result<(), SetLoggerError> {
+    use log::LevelFilter;
+
+    // TODO: dynamically set this based on dlog?
+    log::set_max_level(LevelFilter::Trace);
+
+    log::set_logger(&LOGGER)
+}
+
+/// Set the global panic handler to one which logs the
+/// panic at `LOG_CRIT` level before calling the original
+/// panic hook.
+pub fn set_panic_handler() {
+    use ccommon_sys::LOG_CRIT;
+
+    use std::env;
+    use std::io::Cursor;
+
+    // After logging the message we want to call whatever existing
+    // panic hook was in place. In most cases this should be the
+    // default hook.
+    let old_hook = panic::take_hook();
+
+    panic::set_hook(Box::new(move |info: &PanicInfo| {
+        let mut buffer = [0u8; LOG_MAX_LEN as usize + 1];
+        let ptr = ccommon_dlog().load(Ordering::Relaxed);
+
+        let msg = if let Some(s) = info.payload().downcast_ref::<&str>() {
+            *s
+        } else if let Some(s) = info.payload().downcast_ref::<String>() {
+            &s[..]
+        } else {
+            "Box<Any>"
+        };
+
+        // Cursor so that we can get the number of bytes written afterwards
+        let mut cursor = Cursor::new(&mut buffer[0..LOG_MAX_LEN as usize]);
+
+        // If the thread has a name then use it. (This mirrors std's standard
+        // debug handler)
+        let current_thread = thread::current();
+        let name = current_thread.name().unwrap_or("<unnamed>");
+
+        if let Some(ref location) = info.location() {
+            let _ = write!(
+                &mut cursor,
+                "thread '{}' panicked at '{}', {}",
+                name, msg, *location
+            );
+        } else {
+            let _ = write!(&mut cursor, "thread '{}' panicked at '{}'", name, msg);
+        };
+
+        if !ptr.is_null() {
+            // Ensure that the panic message is logged
+            // TODO(sean): Do we want to log the backtrace as well?
+            if let Some(location) = info.location() {
+                unsafe {
+                    _log(
+                        ptr,
+                        location.file().as_ptr() as *const c_char,
+                        location.line() as c_int,
+                        LOG_CRIT as c_int,
+                        (&buffer).as_ptr() as *const c_char,
+                    );
+                }
+            } else {
+                unsafe {
+                    _log(
+                        ptr,
+                        file!().as_ptr() as *const c_char,
+                        line!() as c_int,
+                        LOG_CRIT as c_int,
+                        (&buffer).as_ptr() as *const c_char,
+                    )
+                }
+            }
+        }
+
+        let old_val = env::var_os("RUST_BACKTRACE");
+        // If possible, have the stdlib display a backtrace
+        env::set_var("RUST_BACKTRACE", "full");
+        old_hook(info);
+
+        if let Some(var) = old_val {
+            env::set_var("RUST_BACKTRACE", var);
+        }
+    }))
+}
+
+//================================================
+// C Interface Methods
+//================================================
+
+#[no_mangle]
+pub extern "C" fn rust_log_setup() -> ccommon_sys::rstatus_i {
+    use ccommon_sys::*;
+
+    match init() {
+        Ok(()) => CC_OK as rstatus_i,
+        Err(_) => CC_ERROR,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn rust_log_teardown() {
+    // Provided for symmetry with the rest of ccommon, currently a no-op
+}
diff --git a/rust/ccommon-rs/src/metric/counter.rs b/rust/ccommon-rs/src/metric/counter.rs
new file mode 100644
index 000000000..8807a1cab
--- /dev/null
+++ b/rust/ccommon-rs/src/metric/counter.rs
@@ -0,0 +1,113 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+use std::ops::{AddAssign, SubAssign};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use ccommon_sys::{metric, metric_anon_union, METRIC_COUNTER};
+
+use super::private::Sealed;
+use super::SingleMetric;
+
+/// An atomic counter metric.
+///
+/// Exposes `incr` and `decr` operations that can also be
+/// used via operators `+=` and `-=`.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Counter(metric);
+
+unsafe impl Send for Counter {}
+unsafe impl Sync for Counter {}
+
+impl Counter {
+    fn as_ref(&self) -> &AtomicU64 {
+        unsafe { &*self.0.data.as_ptr::<AtomicU64>() }
+    }
+
+    /// Increment the counter by `n` atomically.
+    pub fn incr_n(&self, n: u64) {
+        self.as_ref().fetch_add(n, Ordering::Relaxed);
+    }
+
+    /// Increment the counter by `1` atomically.
+    pub fn incr(&self) {
+        self.incr_n(1)
+    }
+
+    /// Decrement the counter by `n` atomically.
+    pub fn decr_n(&self, n: u64) {
+        self.as_ref().fetch_sub(n, Ordering::Relaxed);
+    }
+
+    /// Decrement the counter by `1` atomically.
+    pub fn decr(&self) {
+        self.decr_n(1)
+    }
+
+    /// Atomically store a value in the counter.
+    pub fn update(&self, val: u64) {
+        self.as_ref().store(val, Ordering::Relaxed)
+    }
+
+    /// Atomically get the value out of the counter.
+    pub fn value(&self) -> u64 {
+        self.as_ref().load(Ordering::Relaxed)
+    }
+}
+
+impl Sealed for Counter {}
+
+unsafe impl SingleMetric for Counter {
+    fn new(name: &CStr, desc: &CStr) -> Self {
+        Self(metric {
+            name: name.as_ptr() as *mut i8,
+            desc: desc.as_ptr() as *mut i8,
+            type_: METRIC_COUNTER,
+            data: metric_anon_union::counter(0),
+        })
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.desc) }
+    }
+}
+
+impl fmt::Debug for Counter {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Counter")
+            .field("name", unsafe { &CStr::from_ptr(self.0.name as *const i8) })
+            .field("desc", unsafe { &CStr::from_ptr(self.0.desc as *const i8) })
+            .field("counter", &self.value())
+            .finish()
+    }
+}
+
+impl AddAssign<u64> for Counter {
+    fn add_assign(&mut self, val: u64) {
+        self.incr_n(val);
+    }
+}
+
+impl SubAssign<u64> for Counter {
+    fn sub_assign(&mut self, val: u64) {
+        self.decr_n(val);
+    }
+}
diff --git a/rust/ccommon-rs/src/metric/fpn.rs b/rust/ccommon-rs/src/metric/fpn.rs
new file mode 100644
index 000000000..3e1b02d4d
--- /dev/null
+++ b/rust/ccommon-rs/src/metric/fpn.rs
@@ -0,0 +1,73 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use ccommon_sys::{metric, metric_anon_union, METRIC_FPN};
+
+use super::private::Sealed;
+use super::SingleMetric;
+
+/// A `f64` metric that can be updated atomically.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Fpn(metric);
+
+impl Fpn {
+    /// Get the value atomically.
+    pub fn value(&self) -> f64 {
+        f64::from_bits(unsafe { (*self.0.data.as_ptr::<AtomicU64>()).load(Ordering::Relaxed) })
+    }
+
+    /// Update the value atomically.
+    pub fn update(&self, val: f64) {
+        unsafe { (*self.0.data.as_ptr::<AtomicU64>()).store(val.to_bits(), Ordering::Relaxed) }
+    }
+}
+
+impl Sealed for Fpn {}
+
+unsafe impl Send for Fpn {}
+unsafe impl Sync for Fpn {}
+
+unsafe impl SingleMetric for Fpn {
+    fn new(name: &CStr, desc: &CStr) -> Self {
+        Self(metric {
+            name: name.as_ptr() as *mut i8,
+            desc: desc.as_ptr() as *mut i8,
+            type_: METRIC_FPN,
+            data: metric_anon_union::gauge(0),
+        })
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.desc) }
+    }
+}
+
+impl fmt::Debug for Fpn {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Fpn")
+            .field("name", unsafe { &CStr::from_ptr(self.0.name as *const i8) })
+            .field("desc", unsafe { &CStr::from_ptr(self.0.desc as *const i8) })
+            .field("fpn", &self.value())
+            .finish()
+    }
+}
diff --git a/rust/ccommon-rs/src/metric/gauge.rs b/rust/ccommon-rs/src/metric/gauge.rs
new file mode 100644
index 000000000..334dabe8f
--- /dev/null
+++ b/rust/ccommon-rs/src/metric/gauge.rs
@@ -0,0 +1,113 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+use std::ops::{AddAssign, SubAssign};
+use std::sync::atomic::{AtomicI64, Ordering};
+
+use ccommon_sys::{metric, metric_anon_union, METRIC_GAUGE};
+
+use super::private::Sealed;
+use super::SingleMetric;
+
+/// A gauge metric that can be updated atomically.
+///
+/// Exposes `incr`, `decr`, and `update`. `incr` and `decr`
+/// can be used through operators `+=` and `-=`.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Gauge(metric);
+
+impl Gauge {
+    fn as_ref(&self) -> &AtomicI64 {
+        unsafe { &*self.0.data.as_ptr::<AtomicI64>() }
+    }
+
+    /// Increment the gauge atomically by `n`.
+    pub fn incr_n(&self, n: i64) {
+        self.as_ref().fetch_add(n, Ordering::Relaxed);
+    }
+
+    /// Increment the gauge atomically by `1`.
+    pub fn incr(&self) {
+        self.incr_n(1)
+    }
+
+    /// Decrement the gauge atomically by `n`.
+    pub fn decr_n(&self, n: i64) {
+        self.as_ref().fetch_sub(n, Ordering::Relaxed);
+    }
+
+    /// Decrement the gauge atomically by `1`.
+    pub fn decr(&self) {
+        self.decr_n(1)
+    }
+
+    /// Set the value of the gauge atomically.
+    pub fn update(&self, val: i64) {
+        self.as_ref().store(val, Ordering::Relaxed)
+    }
+
+    /// Get the value of the gauge atomically.
+    pub fn value(&self) -> i64 {
+        self.as_ref().load(Ordering::Relaxed)
+    }
+}
+
+impl Sealed for Gauge {}
+
+unsafe impl Send for Gauge {}
+unsafe impl Sync for Gauge {}
+
+unsafe impl SingleMetric for Gauge {
+    fn new(name: &CStr, desc: &CStr) -> Self {
+        Self(metric {
+            name: name.as_ptr() as *mut i8,
+            desc: desc.as_ptr() as *mut i8,
+            type_: METRIC_GAUGE,
+            data: metric_anon_union::gauge(0),
+        })
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.desc) }
+    }
+}
+
+impl fmt::Debug for Gauge {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Counter")
+            .field("name", unsafe { &CStr::from_ptr(self.0.name as *const i8) })
+            .field("desc", unsafe { &CStr::from_ptr(self.0.desc as *const i8) })
+            .field("counter", &self.value())
+            .finish()
+    }
+}
+
+impl AddAssign<i64> for Gauge {
+    fn add_assign(&mut self, val: i64) {
+        self.incr_n(val);
+    }
+}
+
+impl SubAssign<i64> for Gauge {
+    fn sub_assign(&mut self, val: i64) {
+        self.decr_n(val);
+    }
+}
diff --git a/rust/ccommon-rs/src/metric/mod.rs b/rust/ccommon-rs/src/metric/mod.rs
new file mode 100644
index 000000000..b07070fc8
--- /dev/null
+++ b/rust/ccommon-rs/src/metric/mod.rs
@@ -0,0 +1,364 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Types and methods for dealing with ccommon metrics.
+//!
+//! To use this any collection of metrics (i.e. a struct containing metrics)
+//! should implement the `Metrics` trait through the derive macro. This
+//! will (usually) assert that the struct you are using is equivalent in
+//! memory to an array of `metric` structs.
+
+use std::ffi::CStr;
+
+use ccommon_sys::{metric, metric_describe_all, metric_reset};
+
+// Sealed trait to prevent SingleMetric from ever being implemented
+// from outside of this crate.
+mod private {
+    pub trait Sealed {}
+}
+
+mod counter;
+mod fpn;
+mod gauge;
+
+pub use self::counter::Counter;
+pub use self::fpn::Fpn;
+pub use self::gauge::Gauge;
+
+/// A single metric value.
+///
+/// This trait is sealed and cannot be implemented outside
+/// of ccommon_rs.
+pub unsafe trait SingleMetric: self::private::Sealed {
+    /// Create a metric with the given description and name.
+    ///
+    /// Normally this should only be called by the
+    /// derive macro for `Metrics`.
+    fn new(name: &'static CStr, desc: &'static CStr) -> Self;
+
+    /// The metric's name
+    fn name(&self) -> &'static CStr;
+    /// The metric's description
+    fn desc(&self) -> &'static CStr;
+}
+
+/// A type that can be safely viewed as a contiguous array
+/// of [`metric`s][0].
+///
+/// It should usually only be implemented through `#[derive(Metrics)]`.
+/// However, it must be implemented manually for C types that have
+/// been bound through bindgen.
+///
+/// [0]: ../../cc_binding/struct.metric.html
+pub unsafe trait Metrics: Sized {
+    fn new() -> Self;
+}
+
+pub trait MetricExt: Metrics {
+    /// The number of metrics in this object when
+    /// it is interpreted as an array.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of the size of `metric`.
+    fn num_metrics() -> usize {
+        use std::mem::size_of;
+
+        // If this assert fails then there was no way that
+        // options upholds it's safety requirements so it's
+        // better to fail here.
+        assert!(size_of::<Self>() % size_of::<metric>() == 0);
+
+        // If this assert fails then we'll pass an invalid
+        // size to several ccommon methods.
+        assert!(size_of::<Self>() / size_of::<metric>() < std::u32::MAX as usize);
+
+        size_of::<Self>() / size_of::<metric>()
+    }
+
+    /// Get `self` as a const pointer to an array of `metric`s.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of the size of `metric`.
+    fn as_ptr(&self) -> *const metric {
+        assert!(std::mem::size_of::<Self>() % std::mem::size_of::<metric>() == 0);
+
+        self as *const _ as *const metric
+    }
+
+    /// Get `self` as a mutable pointer to an array of `metric`s.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of the size of `metric`.
+    fn as_mut_ptr(&mut self) -> *mut metric {
+        assert!(std::mem::size_of::<Self>() % std::mem::size_of::<metric>() == 0);
+
+        self as *mut _ as *mut metric
+    }
+
+    /// Print a description of all metricss in the current object
+    /// given using the name and description.
+    ///
+    /// Internally this calls out to `metric_describe_all`.
+    fn describe_all(&self) {
+        unsafe {
+            metric_describe_all(
+                // Note: ccommon uses a mutable pointer but it
+                //       should really be a const pointer.
+                self.as_ptr() as *mut _,
+                Self::num_metrics() as u32,
+            )
+        }
+    }
+
+    /// Reset all metrics to their default values.
+    ///
+    /// This means that all 3 types of metrics are reset to 0.
+    ///
+    /// Internally this calls out to `metric_reset`.
+    fn reset_all(&mut self) {
+        unsafe { metric_reset(self.as_mut_ptr(), Self::num_metrics() as u32) }
+    }
+}
+
+impl<T: Metrics> MetricExt for T {}
+
+/// Impls of Metrics for cc_bindings types
+mod impls {
+    use super::Metrics;
+    use ccommon_sys::*;
+
+    macro_rules! c_str {
+        ($s:expr) => {
+            concat!($s, "\0").as_bytes().as_ptr() as *const i8 as *mut _
+        };
+    }
+
+    macro_rules! initialize_metric_value {
+        (METRIC_GAUGE) => {
+            metric_anon_union::gauge(0)
+        };
+        (METRIC_COUNTER) => {
+            metric_anon_union::counter(0)
+        };
+        (METRIC_FPN) => {
+            metric_anon_union::fpn(0.0)
+        };
+    }
+
+    macro_rules! impl_metrics {
+        {
+            $(
+                impl Metrics for $metrics_ty:ty {
+                    $(
+                        ACTION( $field:ident, $type:ident, $desc:expr )
+                    )*
+                }
+            )*
+        } => {
+            $(
+                unsafe impl Metrics for $metrics_ty {
+                    fn new() -> Self {
+                        Self {
+                            $(
+                                $field: metric {
+                                    name: c_str!(stringify!($field)),
+                                    type_: $type,
+                                    desc: c_str!($desc),
+                                    data: initialize_metric_value!($type)
+                                },
+                            )*
+                        }
+                    }
+                }
+            )*
+        }
+    }
+
+    impl_metrics! {
+        impl Metrics for buf_metrics_st {
+            ACTION( buf_curr,         METRIC_GAUGE,   "# buf allocated"                        )
+            ACTION( buf_active,       METRIC_GAUGE,   "# buf in use/borrowed"                  )
+            ACTION( buf_create,       METRIC_COUNTER, "# buf creates"                          )
+            ACTION( buf_create_ex,    METRIC_COUNTER, "# buf create exceptions"                )
+            ACTION( buf_destroy,      METRIC_COUNTER, "# buf destroys"                         )
+            ACTION( buf_borrow,       METRIC_COUNTER, "# buf borrows"                          )
+            ACTION( buf_borrow_ex,    METRIC_COUNTER, "# buf borrow exceptions"                )
+            ACTION( buf_return,       METRIC_COUNTER, "# buf returns"                          )
+            ACTION( buf_memory,       METRIC_GAUGE,   "memory alloc'd to buf including header" )
+        }
+
+        impl Metrics for dbuf_metrics_st {
+            ACTION( dbuf_double,    METRIC_COUNTER, "# double completed"   )
+            ACTION( dbuf_double_ex, METRIC_COUNTER, "# double failed"      )
+            ACTION( dbuf_shrink,    METRIC_COUNTER, "# shrink completed"   )
+            ACTION( dbuf_shrink_ex, METRIC_COUNTER, "# shrink failed"      )
+            ACTION( dbuf_fit,       METRIC_COUNTER, "# fit completed"      )
+            ACTION( dbuf_fit_ex,    METRIC_COUNTER, "# fit failed"         )
+        }
+
+        impl Metrics for pipe_metrics_st {
+            ACTION( pipe_conn_create,    METRIC_COUNTER, "# pipe connections created"    )
+            ACTION( pipe_conn_create_ex, METRIC_COUNTER, "# pipe conn create exceptions" )
+            ACTION( pipe_conn_destroy,   METRIC_COUNTER, "# pipe connections destroyed"  )
+            ACTION( pipe_conn_curr ,     METRIC_GAUGE,   "# pipe conn allocated"         )
+            ACTION( pipe_conn_borrow,    METRIC_COUNTER, "# pipe connections borrowed"   )
+            ACTION( pipe_conn_borrow_ex, METRIC_COUNTER, "# pipe conn borrow exceptions" )
+            ACTION( pipe_conn_return,    METRIC_COUNTER, "# pipe connections returned"   )
+            ACTION( pipe_conn_active,    METRIC_GAUGE,   "# pipe conn being borrowed"    )
+            ACTION( pipe_open,           METRIC_COUNTER, "# pipe connects made"          )
+            ACTION( pipe_open_ex,        METRIC_COUNTER, "# pipe connect exceptions"     )
+            ACTION( pipe_close,          METRIC_COUNTER, "# pipe connection closed"      )
+            ACTION( pipe_recv,           METRIC_COUNTER, "# recv attempted"              )
+            ACTION( pipe_recv_ex,        METRIC_COUNTER, "# recv exceptions"             )
+            ACTION( pipe_recv_byte,      METRIC_COUNTER, "# bytes received"              )
+            ACTION( pipe_send,           METRIC_COUNTER, "# send attempted"              )
+            ACTION( pipe_send_ex,        METRIC_COUNTER, "# send exceptions"             )
+            ACTION( pipe_send_byte,      METRIC_COUNTER, "# bytes sent"                  )
+            ACTION( pipe_flag_ex,        METRIC_COUNTER, "# pipe flag exceptions"        )
+        }
+
+        impl Metrics for tcp_metrics_st {
+            ACTION( tcp_conn_create,    METRIC_COUNTER, "# tcp connections created"    )
+            ACTION( tcp_conn_create_ex, METRIC_COUNTER, "# tcp conn create exceptions" )
+            ACTION( tcp_conn_destroy,   METRIC_COUNTER, "# tcp connections destroyed"  )
+            ACTION( tcp_conn_curr,      METRIC_GAUGE,   "# tcp conn allocated"         )
+            ACTION( tcp_conn_borrow,    METRIC_COUNTER, "# tcp connections borrowed"   )
+            ACTION( tcp_conn_borrow_ex, METRIC_COUNTER, "# tcp conn borrow exceptions" )
+            ACTION( tcp_conn_return,    METRIC_COUNTER, "# tcp connections returned"   )
+            ACTION( tcp_conn_active,    METRIC_GAUGE,   "# tcp conn being borrowed"    )
+            ACTION( tcp_accept,         METRIC_COUNTER, "# tcp connection accepts"     )
+            ACTION( tcp_accept_ex,      METRIC_COUNTER, "# tcp accept exceptions"      )
+            ACTION( tcp_reject,         METRIC_COUNTER, "# tcp connection rejects"     )
+            ACTION( tcp_reject_ex,      METRIC_COUNTER, "# tcp reject exceptions"      )
+            ACTION( tcp_connect,        METRIC_COUNTER, "# tcp connects made"          )
+            ACTION( tcp_connect_ex,     METRIC_COUNTER, "# tcp connect exceptions "    )
+            ACTION( tcp_close,          METRIC_COUNTER, "# tcp connection closed"      )
+            ACTION( tcp_recv,           METRIC_COUNTER, "# recv attempted"             )
+            ACTION( tcp_recv_ex,        METRIC_COUNTER, "# recv exceptions"            )
+            ACTION( tcp_recv_byte,      METRIC_COUNTER, "# bytes received"             )
+            ACTION( tcp_send,           METRIC_COUNTER, "# send attempted"             )
+            ACTION( tcp_send_ex,        METRIC_COUNTER, "# send exceptions"            )
+            ACTION( tcp_send_byte,      METRIC_COUNTER, "# bytes sent"                 )
+        }
+
+        impl Metrics for sockio_metrics_st {
+            ACTION( buf_sock_create,    METRIC_COUNTER, "# buf sock created"           )
+            ACTION( buf_sock_create_ex, METRIC_COUNTER, "# buf sock create exceptions" )
+            ACTION( buf_sock_destroy,   METRIC_COUNTER, "# buf sock destroyed"         )
+            ACTION( buf_sock_curr,      METRIC_GAUGE,   "# buf sock allocated"         )
+            ACTION( buf_sock_borrow,    METRIC_COUNTER, "# buf sock borrowed"          )
+            ACTION( buf_sock_borrow_ex, METRIC_COUNTER, "# buf sock borrow exceptions" )
+            ACTION( buf_sock_return,    METRIC_COUNTER, "# buf sock returned"          )
+            ACTION( buf_sock_active,    METRIC_GAUGE,   "# buf sock being borrowed"    )
+        }
+
+        impl Metrics for timing_wheel_metrics_st {
+            ACTION( timeout_event_curr,     METRIC_GAUGE,   "# timeout events allocated"   )
+            ACTION( timeout_event_active,   METRIC_GAUGE,   "# timeout events in use"      )
+            ACTION( timeout_event_borrow,   METRIC_COUNTER, "# timeout events borrowed"    )
+            ACTION( timeout_event_borrow_ex,METRIC_COUNTER, "# tevents borrow errors"      )
+            ACTION( timeout_event_return,   METRIC_COUNTER, "# timeout events returned"    )
+            ACTION( timing_wheel_insert,    METRIC_COUNTER, "# tevent insertions"          )
+            ACTION( timing_wheel_remove,    METRIC_COUNTER, "# tevent removal"             )
+            ACTION( timing_wheel_event,     METRIC_GAUGE,   "# tevents in timing wheels"   )
+            ACTION( timing_wheel_process,   METRIC_COUNTER, "# tevents processed"          )
+            ACTION( timing_wheel_tick,      METRIC_COUNTER, "# ticks processed"            )
+            ACTION( timing_wheel_exec,      METRIC_COUNTER, "# timing wheel executions "   )
+        }
+
+        impl Metrics for event_metrics_st {
+            ACTION( event_total,        METRIC_COUNTER, "# events returned"    )
+            ACTION( event_loop,         METRIC_COUNTER, "# event loop returns" )
+            ACTION( event_read,         METRIC_COUNTER, "# reads registered"   )
+            ACTION( event_write,        METRIC_COUNTER, "# writes registered"  )
+        }
+
+        impl Metrics for log_metrics_st {
+            ACTION( log_create,     METRIC_COUNTER, "# loggers created"                )
+            ACTION( log_create_ex,  METRIC_COUNTER, "# log create errors"              )
+            ACTION( log_destroy,    METRIC_COUNTER, "# loggers destroyed"              )
+            ACTION( log_curr,       METRIC_GAUGE,   "current # loggers"                )
+            ACTION( log_open,       METRIC_COUNTER, "# files opened by loggers"        )
+            ACTION( log_open_ex,    METRIC_COUNTER, "# logger open file errors"        )
+            ACTION( log_write,      METRIC_COUNTER, "# log messages written"           )
+            ACTION( log_write_byte, METRIC_COUNTER, "# bytes written by log"           )
+            ACTION( log_write_ex,   METRIC_COUNTER, "# log write errors"               )
+            ACTION( log_skip,       METRIC_COUNTER, "# messages not completely logged" )
+            ACTION( log_skip_byte,  METRIC_COUNTER, "# bytes unable to be logged"      )
+            ACTION( log_flush,      METRIC_COUNTER, "# log flushes to disk"            )
+            ACTION( log_flush_ex,   METRIC_COUNTER, "# errors flushing to disk"        )
+        }
+
+        impl Metrics for rbuf_metrics_st {
+            ACTION( rbuf_create,    METRIC_COUNTER, "# rbuf created"         )
+            ACTION( rbuf_create_ex, METRIC_COUNTER, "# rbuf create errors"   )
+            ACTION( rbuf_destroy,   METRIC_COUNTER, "# rbuf destroyed"       )
+            ACTION( rbuf_curr,      METRIC_GAUGE,   "# rbuf allocated"       )
+            ACTION( rbuf_byte,      METRIC_GAUGE,   "# rbuf bytes allocated" )
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    macro_rules! c_str {
+        ($s:expr) => {
+            unsafe { CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes()) }
+        };
+    }
+
+    #[test]
+    fn gauge_basic_use() {
+        let gauge = Gauge::new(c_str!("test"), c_str!("test desc"));
+
+        assert_eq!(gauge.value(), 0);
+        gauge.incr();
+        assert_eq!(gauge.value(), 1);
+        gauge.decr_n(10);
+        assert_eq!(gauge.value(), -9);
+    }
+
+    #[test]
+    fn counter_basic_use() {
+        let ctr = Counter::new(c_str!("test"), c_str!("test desc"));
+
+        assert_eq!(ctr.value(), 0);
+        ctr.incr();
+        assert_eq!(ctr.value(), 1);
+        ctr.incr_n(400);
+        assert_eq!(ctr.value(), 401);
+    }
+
+    #[test]
+    fn fpn_basic_use() {
+        let fpn = Fpn::new(c_str!("test"), c_str!("test desc"));
+
+        assert_eq!(fpn.value(), 0.0);
+        fpn.update(500.0);
+        assert_eq!(fpn.value(), 500.0);
+    }
+
+    #[test]
+    fn size_sanity_test() {
+        // Protect against a bad bindgen run
+        assert!(std::mem::size_of::<metric>() != 0);
+    }
+}
diff --git a/rust/ccommon-rs/src/option/boolean.rs b/rust/ccommon-rs/src/option/boolean.rs
new file mode 100644
index 000000000..713acf5ce
--- /dev/null
+++ b/rust/ccommon-rs/src/option/boolean.rs
@@ -0,0 +1,81 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+
+use ccommon_sys::{option, option_val_u, OPTION_TYPE_BOOL};
+
+use super::{Sealed, SingleOption};
+
+/// A boolean option.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Bool(option);
+
+impl Sealed for Bool {}
+
+unsafe impl Send for Bool {}
+
+unsafe impl SingleOption for Bool {
+    type Value = bool;
+
+    fn new(default: bool, name: &'static CStr, desc: &'static CStr) -> Self {
+        Self(option {
+            name: name.as_ptr() as *mut _,
+            set: false,
+            type_: OPTION_TYPE_BOOL,
+            default_val: option_val_u { vbool: default },
+            val: option_val_u { vbool: default },
+            description: desc.as_ptr() as *mut _,
+        })
+    }
+    fn defaulted(name: &'static CStr, desc: &'static CStr) -> Self {
+        Self::new(Default::default(), name, desc)
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.description) }
+    }
+    fn value(&self) -> Self::Value {
+        unsafe { self.0.val.vbool }
+    }
+    fn default(&self) -> Self::Value {
+        unsafe { self.0.default_val.vbool }
+    }
+    fn is_set(&self) -> bool {
+        self.0.set
+    }
+
+    fn set_value(&mut self, val: Self::Value) {
+        self.0.set = true;
+        self.0.val = option_val_u { vbool: val }
+    }
+}
+
+impl fmt::Debug for Bool {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Bool")
+            .field("name", &self.name())
+            .field("desc", &self.desc())
+            .field("value", &self.value())
+            .field("default", &self.default())
+            .field("is_set", &self.is_set())
+            .finish()
+    }
+}
diff --git a/rust/ccommon-rs/src/option/fpn.rs b/rust/ccommon-rs/src/option/fpn.rs
new file mode 100644
index 000000000..4f392a023
--- /dev/null
+++ b/rust/ccommon-rs/src/option/fpn.rs
@@ -0,0 +1,81 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+
+use ccommon_sys::{option, option_val_u, OPTION_TYPE_FPN};
+
+use super::{Sealed, SingleOption};
+
+/// A floating-point option.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Float(option);
+
+impl Sealed for Float {}
+
+unsafe impl Send for Float {}
+
+unsafe impl SingleOption for Float {
+    type Value = f64;
+
+    fn new(default: Self::Value, name: &'static CStr, desc: &'static CStr) -> Self {
+        Self(option {
+            name: name.as_ptr() as *mut _,
+            set: false,
+            type_: OPTION_TYPE_FPN,
+            default_val: option_val_u { vfpn: default },
+            val: option_val_u { vfpn: default },
+            description: desc.as_ptr() as *mut _,
+        })
+    }
+    fn defaulted(name: &'static CStr, desc: &'static CStr) -> Self {
+        Self::new(Default::default(), name, desc)
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.description) }
+    }
+    fn value(&self) -> Self::Value {
+        unsafe { self.0.val.vfpn }
+    }
+    fn default(&self) -> Self::Value {
+        unsafe { self.0.default_val.vfpn }
+    }
+    fn is_set(&self) -> bool {
+        self.0.set
+    }
+
+    fn set_value(&mut self, val: Self::Value) {
+        self.0.set = true;
+        self.0.val = option_val_u { vfpn: val }
+    }
+}
+
+impl fmt::Debug for Float {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Float")
+            .field("name", &self.name())
+            .field("desc", &self.desc())
+            .field("value", &self.value())
+            .field("default", &self.default())
+            .field("is_set", &self.is_set())
+            .finish()
+    }
+}
diff --git a/rust/ccommon-rs/src/option/mod.rs b/rust/ccommon-rs/src/option/mod.rs
new file mode 100644
index 000000000..b2e45d584
--- /dev/null
+++ b/rust/ccommon-rs/src/option/mod.rs
@@ -0,0 +1,357 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Types and methods for dealing with ccommon options.
+//!
+//! See the docs on the `Options` macro to see how to create
+//! new options structs.
+
+use std::ffi::CStr;
+
+use ccommon_backend::option::{
+    option_describe_all, option_load, option_load_default, option_print_all, ParseError,
+};
+use ccommon_sys::option;
+
+// Sealed trait to prevent SingleOption from ever being implemented
+// from outside of this crate.
+mod private {
+    pub trait Sealed {}
+}
+
+use self::private::Sealed;
+
+mod boolean;
+mod fpn;
+mod string;
+mod uint;
+
+pub use self::boolean::Bool;
+pub use self::fpn::Float;
+pub use self::string::Str;
+pub use self::uint::UInt;
+
+/// A single option.
+///
+/// This trait is sealed and cannot be implemented outside
+/// of ccommon_rs.
+pub unsafe trait SingleOption: self::private::Sealed {
+    /// The type of the value contained within this option.
+    type Value;
+
+    /// Create an option with the given description, name,
+    /// and default value.
+    ///
+    /// Normally, this should only be called by the derive
+    /// macro for `Options`.
+    fn new(default: Self::Value, name: &'static CStr, desc: &'static CStr) -> Self;
+
+    /// Create an option with the given description, name,
+    /// and `Default::default()` as the default value.
+    ///
+    /// The only exception is that [`Str`](crate::option::Str)
+    /// uses `std::ptr::null_mut()` as it's default value since
+    /// pointers do not implement `Default`.
+    ///
+    /// Normally, this should only be called by the derive macro
+    /// for `Options`.
+    fn defaulted(name: &'static CStr, desc: &'static CStr) -> Self;
+
+    /// The name of this option
+    fn name(&self) -> &'static CStr;
+    /// A C string describing this option
+    fn desc(&self) -> &'static CStr;
+    /// The current value of this option
+    fn value(&self) -> Self::Value;
+    /// The default value for this option
+    fn default(&self) -> Self::Value;
+    /// Whether the option has been set externally
+    fn is_set(&self) -> bool;
+
+    /// Overwrite the current value for the option.
+    ///
+    /// This will always set `is_set` to true.
+    fn set_value(&mut self, val: Self::Value);
+}
+
+/// A type that can be safely viewed as a contiguous
+/// array of [`option`s][0].
+///
+/// See [`OptionsExt`] for more useful functions on
+/// `Options`.
+///
+/// This trait should normally only be implemented through
+/// `#[derive(Options)]`. However, it must be implemented
+/// manually for C types which have been bound using bindgen.
+///
+/// [0]: ../../cc_binding/struct.option.html
+pub unsafe trait Options: Sized {
+    fn new() -> Self;
+}
+
+pub trait OptionExt: Options {
+    /// The number of options in this object when it
+    /// is interpreted as an array.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of thie size of `option`.
+    fn num_options() -> usize {
+        use std::mem::size_of;
+
+        // If this assert fails then there was no way that
+        // options upholds it's safety requirements so it's
+        // better to fail here.
+        assert!(size_of::<Self>() % size_of::<option>() == 0);
+
+        // If this assert fails then we'll pass an invalid
+        // size to several ccommon methods.
+        assert!(size_of::<Self>() / size_of::<option>() < std::u32::MAX as usize);
+
+        size_of::<Self>() / size_of::<option>()
+    }
+
+    /// Get `self` as a const pointer to an array of `option`s.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of thie size of `option`.
+    fn as_ptr(&self) -> *const option {
+        self as *const _ as *const option
+    }
+
+    /// Get `self` as a mutable pointer to an array of `option`s.
+    ///
+    /// # Panics
+    /// Panics if the size of this type is not a multiple
+    /// of thie size of `option`.
+    fn as_mut_ptr(&mut self) -> *mut option {
+        self as *mut _ as *mut option
+    }
+
+    /// Get `self` as a slice of `option`s.
+    fn as_slice(&self) -> &[option] {
+        use std::slice;
+
+        // Safe because implementing the trait means that layout
+        // is guaranteed.
+        unsafe { slice::from_raw_parts(self.as_ptr(), Self::num_options()) }
+    }
+
+    /// Get `self` as a mutable slice of `option`s.
+    fn as_mut_slice(&mut self) -> &mut [option] {
+        use std::slice;
+
+        // Safe because implementing the trait means that layout
+        // is guaranteed.
+        unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), Self::num_options()) }
+    }
+
+    /// Print a description of all options in the current object
+    /// given using the default value, name, and description.
+    ///
+    /// Internally this calls out to `option_describe_all`.
+    fn describe_all(&self) {
+        unsafe {
+            option_describe_all(&mut std::io::stdout(), self.as_slice())
+                .expect("Failed to write to stdout");
+        }
+    }
+
+    /// Print out the values of all options.
+    ///
+    /// Internally this calls out to `option_print_all`.
+    fn print_all(&self) {
+        unsafe {
+            option_print_all(&mut std::io::stdout(), self.as_slice())
+                .expect("Failed to write to stdout")
+        }
+    }
+
+    /// Load default values for all options.
+    ///
+    /// Internally this calls `option_load_default`
+    fn load_default(&mut self) -> Result<(), crate::Error> {
+        unsafe { option_load_default(self.as_mut_slice()).map_err(|_| crate::Error::ENoMem) }
+    }
+
+    /// Load options from a file.
+    #[deprecated(note = "Use load instead - this interface is unsafe")]
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
+    fn load_from_libc_file(&mut self, file: *mut libc::FILE) -> Result<(), crate::Error> {
+        use ccommon_backend::compat::CFileRef;
+        use std::io::BufReader;
+
+        let cfile = unsafe { CFileRef::from_ptr_mut(file) };
+        self.load(&mut BufReader::new(cfile))
+            .map_err(|_| crate::Error::EOther)
+    }
+
+    /// Load options from a reader implementing `BufRead`.
+    fn load<R: std::io::BufRead>(&mut self, input: &mut R) -> Result<(), ParseError<'static>> {
+        option_load(self.as_mut_slice(), input)
+    }
+}
+
+impl<T: Options> OptionExt for T {}
+
+/// Implementations of Options for cc_bindings types
+mod impls {
+    use super::Options;
+    use ccommon_sys::*;
+
+    macro_rules! c_str {
+        ($s:expr) => {
+            concat!($s, "\0").as_bytes().as_ptr() as *const i8 as *mut _
+        };
+    }
+
+    macro_rules! initialize_option_value {
+        (OPTION_TYPE_BOOL, $default:expr) => {
+            option_val_u { vbool: $default }
+        };
+        (OPTION_TYPE_UINT, $default:expr) => {
+            option_val_u {
+                vuint: $default.into(),
+            }
+        };
+        (OPTION_TYPE_FPN, $default:expr) => {
+            option_val_u { vfpn: $default }
+        };
+        (OPTION_TYPE_STR, $default:expr) => {
+            option_val_u { vstr: $default }
+        };
+    }
+
+    macro_rules! impl_options {
+        {
+            $(
+                impl Options for $metrics_ty:ty {
+                    $(
+                        ACTION( $field:ident, $type:ident, $default:expr, $desc:expr )
+                    )*
+                }
+            )*
+        } => {
+            $(
+                unsafe impl Options for $metrics_ty {
+                    fn new() -> Self {
+                        Self {
+                            $(
+                                $field: option {
+                                    name: c_str!(stringify!($field)),
+                                    set: false,
+                                    type_: $type,
+                                    default_val: initialize_option_value!($type, $default),
+                                    val: initialize_option_value!($type, $default),
+                                    description: c_str!($desc)
+                                },
+                            )*
+                        }
+                    }
+                }
+            )*
+        }
+    }
+
+    impl_options! {
+        impl Options for buf_options_st {
+            ACTION( buf_init_size,  OPTION_TYPE_UINT,   BUF_DEFAULT_SIZE,   "init buf size incl header" )
+            ACTION( buf_poolsize,   OPTION_TYPE_UINT,   BUF_POOLSIZE,       "buf pool size"             )
+        }
+
+        impl Options for dbuf_options_st {
+            ACTION( dbuf_max_power,      OPTION_TYPE_UINT,  DBUF_DEFAULT_MAX,   "max number of doubles")
+        }
+
+        impl Options for pipe_options_st {
+            ACTION( pipe_poolsize,      OPTION_TYPE_UINT,   PIPE_POOLSIZE,  "pipe conn pool size" )
+        }
+
+        impl Options for tcp_options_st {
+            ACTION( tcp_backlog,    OPTION_TYPE_UINT,   TCP_BACKLOG,    "tcp conn backlog limit" )
+            ACTION( tcp_poolsize,   OPTION_TYPE_UINT,   TCP_POOLSIZE,   "tcp conn pool size"     )
+        }
+
+        impl Options for sockio_options_st {
+            ACTION( buf_sock_poolsize,  OPTION_TYPE_UINT,   BUFSOCK_POOLSIZE,   "buf_sock limit" )
+        }
+
+        impl Options for array_options_st {
+            ACTION( array_nelem_delta,  OPTION_TYPE_UINT,   NELEM_DELTA,      "max nelem delta during expansion" )
+        }
+
+        impl Options for debug_options_st {
+            ACTION( debug_log_level, OPTION_TYPE_UINT, DEBUG_LOG_LEVEL,  "debug log level"     )
+            ACTION( debug_log_file,  OPTION_TYPE_STR,  DEBUG_LOG_FILE,   "debug log file"      )
+            ACTION( debug_log_nbuf,  OPTION_TYPE_UINT, DEBUG_LOG_NBUF,   "debug log buf size"  )
+        }
+
+        impl Options for stats_log_options_st {
+            ACTION( stats_log_file, OPTION_TYPE_STR,  std::ptr::null_mut(), "file storing stats"   )
+            ACTION( stats_log_nbuf, OPTION_TYPE_UINT, STATS_LOG_NBUF,       "stats log buf size"   )
+        }
+    }
+}
+
+use crate::Options;
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::Options;
+
+    #[derive(Options)]
+    #[repr(C)]
+    struct TestOptions {
+        #[option(desc = "The first test option")]
+        opt1: Bool,
+
+        #[option(desc = "The second test option", default = 5)]
+        opt2: UInt,
+
+        #[option(desc = "The third test option", default = 35.0)]
+        opt3: Float,
+    }
+
+    #[test]
+    fn test_option_properties() {
+        assert_eq!(TestOptions::num_options(), 3);
+    }
+
+    #[test]
+    fn test_option_defaults() {
+        let options = TestOptions::new();
+        let ptr =
+            unsafe { std::slice::from_raw_parts(options.as_ptr(), TestOptions::num_options()) };
+
+        unsafe {
+            assert_eq!(ptr[0].default_val.vbool, false);
+            assert_eq!(ptr[0].set, false);
+
+            assert_eq!(ptr[1].default_val.vuint, 5);
+            assert_eq!(ptr[1].set, false);
+
+            assert_eq!(ptr[2].default_val.vfpn, 35.0);
+            assert_eq!(ptr[2].set, false);
+        }
+    }
+
+    #[test]
+    fn option_size_sanity() {
+        // Protect against a bad bindgen run
+        assert!(std::mem::size_of::<option>() != 0);
+    }
+}
diff --git a/rust/ccommon-rs/src/option/string.rs b/rust/ccommon-rs/src/option/string.rs
new file mode 100644
index 000000000..4fb937877
--- /dev/null
+++ b/rust/ccommon-rs/src/option/string.rs
@@ -0,0 +1,109 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+
+use ccommon_sys::{option, option_free, option_val_u, OPTION_TYPE_STR};
+
+use super::{Sealed, SingleOption};
+
+/// A string option.
+///
+/// Note that this type wraps a C string.
+#[repr(transparent)]
+pub struct Str(option);
+
+unsafe impl Send for Str {}
+
+impl Str {
+    /// Get the value of this option as a CStr. If null,
+    /// returns none.
+    pub fn as_cstr(&self) -> Option<&CStr> {
+        let value = self.value();
+
+        if value.is_null() {
+            None
+        } else {
+            Some(unsafe { CStr::from_ptr(value) })
+        }
+    }
+
+    /// Convert this option to a string if possible. Otherwise
+    /// returns None.
+    pub fn as_str(&self) -> Option<&str> {
+        self.as_cstr().and_then(|s| s.to_str().ok())
+    }
+}
+
+impl Sealed for Str {}
+
+unsafe impl SingleOption for Str {
+    type Value = *mut std::os::raw::c_char;
+
+    fn new(default: Self::Value, name: &'static CStr, desc: &'static CStr) -> Self {
+        Self(option {
+            name: name.as_ptr() as *mut _,
+            set: false,
+            type_: OPTION_TYPE_STR,
+            default_val: option_val_u { vstr: default },
+            val: option_val_u { vstr: default },
+            description: desc.as_ptr() as *mut _,
+        })
+    }
+    fn defaulted(name: &'static CStr, desc: &'static CStr) -> Self {
+        Self::new(std::ptr::null_mut(), name, desc)
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.description) }
+    }
+    fn value(&self) -> Self::Value {
+        unsafe { self.0.val.vstr }
+    }
+    fn default(&self) -> Self::Value {
+        unsafe { self.0.default_val.vstr }
+    }
+    fn is_set(&self) -> bool {
+        self.0.set
+    }
+
+    fn set_value(&mut self, val: Self::Value) {
+        self.0.set = true;
+        self.0.val = option_val_u { vstr: val }
+    }
+}
+
+// TODO(sean): Debug print the string pointer
+impl fmt::Debug for Str {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Str")
+            .field("name", &self.name())
+            .field("desc", &self.desc())
+            .field("value", &self.value())
+            .field("default", &self.default())
+            .field("is_set", &self.is_set())
+            .finish()
+    }
+}
+
+impl Drop for Str {
+    fn drop(&mut self) {
+        unsafe { option_free(self as *mut _ as *mut option, 1) }
+    }
+}
diff --git a/rust/ccommon-rs/src/option/uint.rs b/rust/ccommon-rs/src/option/uint.rs
new file mode 100644
index 000000000..6783eeaef
--- /dev/null
+++ b/rust/ccommon-rs/src/option/uint.rs
@@ -0,0 +1,81 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ffi::CStr;
+use std::fmt;
+
+use ccommon_sys::{option, option_val_u, OPTION_TYPE_UINT};
+
+use super::{Sealed, SingleOption};
+
+/// An unsigned integer option.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct UInt(option);
+
+impl Sealed for UInt {}
+
+unsafe impl Send for UInt {}
+
+unsafe impl SingleOption for UInt {
+    type Value = ccommon_sys::uintmax_t;
+
+    fn new(default: Self::Value, name: &'static CStr, desc: &'static CStr) -> Self {
+        Self(option {
+            name: name.as_ptr() as *mut _,
+            set: false,
+            type_: OPTION_TYPE_UINT,
+            default_val: option_val_u { vuint: default },
+            val: option_val_u { vuint: default },
+            description: desc.as_ptr() as *mut _,
+        })
+    }
+    fn defaulted(name: &'static CStr, desc: &'static CStr) -> Self {
+        Self::new(Default::default(), name, desc)
+    }
+
+    fn name(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.name) }
+    }
+    fn desc(&self) -> &'static CStr {
+        unsafe { CStr::from_ptr(self.0.description) }
+    }
+    fn value(&self) -> Self::Value {
+        unsafe { self.0.val.vuint }
+    }
+    fn default(&self) -> Self::Value {
+        unsafe { self.0.default_val.vuint }
+    }
+    fn is_set(&self) -> bool {
+        self.0.set
+    }
+
+    fn set_value(&mut self, val: Self::Value) {
+        self.0.set = true;
+        self.0.val = option_val_u { vuint: val }
+    }
+}
+
+impl fmt::Debug for UInt {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("UInt")
+            .field("name", &self.name())
+            .field("desc", &self.desc())
+            .field("value", &self.value())
+            .field("default", &self.default())
+            .field("is_set", &self.is_set())
+            .finish()
+    }
+}
diff --git a/rust/ccommon-rs/src/ptrs.rs b/rust/ccommon-rs/src/ptrs.rs
new file mode 100644
index 000000000..c847146a9
--- /dev/null
+++ b/rust/ccommon-rs/src/ptrs.rs
@@ -0,0 +1,40 @@
+// ccommon - a cache common library.
+// Copyright (C) 2018 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::ptr;
+use std::result;
+
+#[derive(Fail, Debug)]
+#[fail(display = "Null pointer exception")]
+pub struct NullPointerError;
+
+pub fn lift_to_option<T>(p: *mut T) -> Option<*mut T> {
+    if p.is_null() {
+        None
+    } else {
+        Some(p)
+    }
+}
+
+pub fn null_check<T>(p: *mut T) -> result::Result<*mut T, NullPointerError> {
+    lift_to_option(p).ok_or_else(|| NullPointerError)
+}
+
+pub fn opt_to_null_mut<T>(o: Option<*mut T>) -> *mut T {
+    match o {
+        Some(p) => p,
+        None => ptr::null_mut(),
+    }
+}
diff --git a/rust/ccommon-rs/tests/derive_metrics.rs b/rust/ccommon-rs/tests/derive_metrics.rs
new file mode 100644
index 000000000..07f8ec476
--- /dev/null
+++ b/rust/ccommon-rs/tests/derive_metrics.rs
@@ -0,0 +1,46 @@
+#![cfg(feature = "derive")]
+
+use ccommon_rs::metric::*;
+use ccommon_rs::Metrics;
+
+#[derive(Metrics)]
+#[repr(C)]
+pub struct TestMetrics {
+    #[metric(desc = "A test gauge metric")]
+    pub m1: Gauge,
+    #[metric(desc = "A test counter metric")]
+    pub m2: Counter,
+    #[metric(desc = "A test fpn metric", name = "test.other.m3")]
+    pub m3: Fpn,
+}
+
+#[derive(Metrics)]
+#[repr(C)]
+pub struct Nested {
+    pub inner: TestMetrics,
+    #[metric(desc = "Another test metric", name = "nested.other")]
+    other: Gauge,
+}
+
+#[derive(Metrics)]
+#[repr(transparent)]
+pub struct Tuple(Nested);
+
+#[derive(Metrics)]
+#[repr(C, align(16))]
+pub struct Marker;
+
+macro_rules! c_str {
+    ($s:expr) => {
+        unsafe { std::ffi::CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes()) }
+    };
+}
+
+#[test]
+fn this_compiles() {
+    let nested = Nested::new();
+
+    assert_eq!(nested.other.name(), c_str!("nested.other"));
+    assert_eq!(nested.inner.m3.name(), c_str!("test.other.m3"));
+    assert_eq!(nested.inner.m2.name(), c_str!("m2"));
+}
diff --git a/rust/ccommon-rs/tests/derive_options.rs b/rust/ccommon-rs/tests/derive_options.rs
new file mode 100644
index 000000000..9b57dbb63
--- /dev/null
+++ b/rust/ccommon-rs/tests/derive_options.rs
@@ -0,0 +1,54 @@
+#![cfg(feature = "derive")]
+
+use ccommon_rs::option::*;
+use ccommon_rs::Options;
+
+#[derive(Options)]
+#[repr(C)]
+pub struct TestMetrics {
+    #[option(desc = "A test gauge metric")]
+    pub m1: Float,
+    #[option(desc = "A test counter metric")]
+    pub m2: Bool,
+    #[option(desc = "A test fpn metric", name = "test.other.m3")]
+    pub m3: UInt,
+}
+
+#[derive(Options)]
+#[repr(C)]
+pub struct Nested {
+    pub inner: TestMetrics,
+    #[option(
+        desc = "Another test metric",
+        name = "nested.other",
+        default = std::ptr::null_mut()
+    )]
+    other: Str,
+    #[option(desc = "Defaulted str")]
+    defaulted: Str,
+}
+
+#[derive(Options)]
+#[repr(transparent)]
+pub struct Tuple(Nested);
+
+#[derive(Options)]
+#[repr(C, align(16))]
+pub struct Marker;
+
+macro_rules! c_str {
+    ($s:expr) => {
+        unsafe { std::ffi::CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes()) }
+    };
+}
+
+#[test]
+fn this_compiles() {
+    let nested = Nested::new();
+
+    assert_eq!(nested.other.name(), c_str!("nested.other"));
+    assert_eq!(nested.inner.m3.name(), c_str!("test.other.m3"));
+    assert_eq!(nested.inner.m2.name(), c_str!("m2"));
+    assert_eq!(nested.other.value(), nested.other.default());
+    assert_eq!(nested.other.value(), std::ptr::null_mut());
+}
diff --git a/rust/ccommon-rs/tests/log.rs b/rust/ccommon-rs/tests/log.rs
new file mode 100644
index 000000000..02f734a7e
--- /dev/null
+++ b/rust/ccommon-rs/tests/log.rs
@@ -0,0 +1,140 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// gag doesn't work on windows
+#![cfg(not(windows))]
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate rusty_fork;
+
+use ccommon_rs::log::*;
+
+use std::io::Read;
+use std::os::raw::c_char;
+
+macro_rules! c_str {
+    ($s:expr) => {
+        #[allow(unused_unsafe)]
+        unsafe {
+            std::ffi::CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes())
+        }
+    };
+}
+
+pub fn capture_stderr<F: FnOnce() -> ()>(func: F) -> Result<String, std::io::Error> {
+    let mut buf = gag::BufferRedirect::stderr()?;
+
+    func();
+
+    let mut output = String::new();
+    buf.read_to_string(&mut output)?;
+
+    Ok(output)
+}
+
+fn test_log_printing() {
+    let _logger = DebugLogger::new(None);
+    ccommon_rs::log::init().unwrap();
+
+    let output = capture_stderr(|| {
+        error!("<== TEST ERROR ==>");
+    })
+    .unwrap();
+
+    eprintln!("'{}'", output);
+    assert!(output.contains("<== TEST ERROR ==>"));
+}
+
+fn test_log_levels() {
+    use ccommon_sys::*;
+    use ccommon_rs::option::Options;
+
+    let mut opts = debug_options_st::new();
+    unsafe {
+        // Set log level to debug
+        option_set(
+            &mut opts.debug_log_level as *mut _,
+            c_str!("5").as_ptr() as *const c_char as *mut _,
+        );
+    }
+
+    let _logger = DebugLogger::new(&opts);
+    ccommon_rs::log::init().unwrap();
+
+    let output = capture_stderr(|| {
+        error!("<== ERROR ==>");
+        warn!("<== WARN ==>");
+        info!("<== INFO ==>");
+        debug!("<== DEBUG ==>");
+        trace!("<== TRACE ==>");
+    })
+    .unwrap();
+
+    assert!(output.contains("<== ERROR ==>"));
+    assert!(output.contains("<== WARN ==>"));
+    assert!(output.contains("<== INFO ==>"));
+    assert!(output.contains("<== DEBUG ==>"));
+    assert!(!output.contains("<== TRACE ==>"));
+}
+
+fn test_teardown() {
+    ccommon_rs::log::init().unwrap();
+
+    let output = capture_stderr(|| {
+        info!("<< LOG 1 >>");
+
+        {
+            let _logger = DebugLogger::new(None);
+
+            info!("<< LOG 2 >>");
+            info!("<< LOG 3 >>");
+        }
+
+        info!("<< LOG 4 >>");
+
+        {
+            let _logger = DebugLogger::new(None);
+
+            info!("<< LOG 5 >>");
+        }
+
+        info!("<< LOG 6 >>");
+    })
+    .unwrap();
+
+    assert!(!output.contains("<< LOG 1 >>"));
+    assert!(output.contains("<< LOG 2 >>"));
+    assert!(output.contains("<< LOG 3 >>"));
+    assert!(!output.contains("<< LOG 4 >>"));
+    assert!(output.contains("<< LOG 5 >>"));
+    assert!(!output.contains("<< LOG 6 >>"));
+}
+
+rusty_fork_test! {
+    #[test]
+    fn log_printing() { test_log_printing() }
+}
+
+rusty_fork_test! {
+    #[test]
+    fn log_levels() { test_log_levels() }
+}
+
+rusty_fork_test! {
+    #[test]
+    fn teardown() { test_teardown() }
+}
diff --git a/rust/ccommon-stats/CMakeLists.txt b/rust/ccommon-stats/CMakeLists.txt
new file mode 100644
index 000000000..f35d0e554
--- /dev/null
+++ b/rust/ccommon-stats/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-stats)
diff --git a/rust/ccommon-stats/Cargo.toml b/rust/ccommon-stats/Cargo.toml
new file mode 100644
index 000000000..1956778b4
--- /dev/null
+++ b/rust/ccommon-stats/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "ccommon-stats"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
+
diff --git a/rust/ccommon-stats/src/lib.rs b/rust/ccommon-stats/src/lib.rs
new file mode 100644
index 000000000..182f3a4ad
--- /dev/null
+++ b/rust/ccommon-stats/src/lib.rs
@@ -0,0 +1,50 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const STATS_LOG_FILE: Option<String> = None;
+const STATS_LOG_NBUF: usize = 0;
+
+// helper functions
+fn file() -> Option<String> {
+    STATS_LOG_FILE
+}
+
+fn nbuf() -> usize {
+    STATS_LOG_NBUF
+}
+
+// definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct StatsLogConfig {
+	#[cfg_attr(feature = "serde", serde(default = "file"))]
+    file: Option<String>,
+    #[cfg_attr(feature = "serde", serde(default = "nbuf"))]
+    nbuf: usize,
+}
+
+// implementation
+impl StatsLogConfig {
+    pub fn log_file(&self) -> Option<String> {
+        self.file.clone()
+    }
+
+    pub fn log_nbuf(&self) -> usize {
+        self.nbuf
+    }
+}
+
+// trait implementations
+impl Default for StatsLogConfig {
+    fn default() -> Self {
+        Self {
+            file: file(),
+            nbuf: nbuf(),
+        }
+    }
+}
diff --git a/rust/ccommon-stream/CMakeLists.txt b/rust/ccommon-stream/CMakeLists.txt
new file mode 100644
index 000000000..ec65970df
--- /dev/null
+++ b/rust/ccommon-stream/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+cargo_build(NAME ccommon-stream)
diff --git a/rust/ccommon-stream/Cargo.toml b/rust/ccommon-stream/Cargo.toml
new file mode 100644
index 000000000..fd2067678
--- /dev/null
+++ b/rust/ccommon-stream/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "ccommon-stream"
+version = "0.1.0"
+authors = ["Brian Martin <bmartin@twitter.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.110", features = ["derive"], optional = true }
+
+[features]
+default = [ "serde/derive" ]
+
diff --git a/rust/ccommon-stream/src/lib.rs b/rust/ccommon-stream/src/lib.rs
new file mode 100644
index 000000000..ad1451406
--- /dev/null
+++ b/rust/ccommon-stream/src/lib.rs
@@ -0,0 +1,38 @@
+// Copyright 2020 Twitter, Inc.
+// Licensed under the Apache License, Version 2.0
+// http://www.apache.org/licenses/LICENSE-2.0
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// constants to define default values
+const BUFSOCK_POOLSIZE: usize = 0;
+
+// helper functions
+fn buf_sock_poolsize() -> usize {
+    BUFSOCK_POOLSIZE
+}
+
+// definitions
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct SockioConfig {
+	#[cfg_attr(feature = "serde", serde(default = "buf_sock_poolsize"))]
+    buf_sock_poolsize: usize,
+}
+
+// implementation
+impl SockioConfig {
+    pub fn buf_sock_poolsize(&self) -> usize {
+        self.buf_sock_poolsize
+    }
+}
+
+// trait implementations
+impl Default for SockioConfig {
+    fn default() -> Self {
+        Self {
+            buf_sock_poolsize: buf_sock_poolsize(),
+        }
+    }
+}
diff --git a/rust/ccommon-sys/CMakeLists.txt b/rust/ccommon-sys/CMakeLists.txt
new file mode 100644
index 000000000..b23f40044
--- /dev/null
+++ b/rust/ccommon-sys/CMakeLists.txt
@@ -0,0 +1,5 @@
+cargo_build(NAME ccommon-sys)
+
+target_link_libraries(ccommon-sys INTERFACE ccommon-static)
+
+add_dependencies(ccommon-sys ccommon-static)
diff --git a/rust/ccommon-sys/Cargo.toml b/rust/ccommon-sys/Cargo.toml
new file mode 100644
index 000000000..5b9804344
--- /dev/null
+++ b/rust/ccommon-sys/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "ccommon-sys"
+version = "0.1.0"
+authors = [
+	"Brian Martin <bmartin@twitter.com>",
+	"Jonathan Simms <jsimms@twitter.com>",
+	"Sean Lynch <slynch@twitter.com>"
+]
+edition = "2018"
+
+[dependencies]
+libc = "0.2.68"
+
+[build-dependencies]
+bindgen = "0.53.2"
+cmake = "0.1.42"
diff --git a/rust/ccommon-sys/build.rs b/rust/ccommon-sys/build.rs
new file mode 100644
index 000000000..2ea0bf2a3
--- /dev/null
+++ b/rust/ccommon-sys/build.rs
@@ -0,0 +1,142 @@
+fn main() {
+    let dst = cmake::build("../..");
+
+    println!("cargo:rustc-link-search=native={}/lib", dst.display());
+    println!("cargo:rustc-link-lib=static=ccommon-2.1.0");
+    if cfg!(target_os = "macos") {
+        println!("cargo:rustc-link-search=framework=/System/Library/Frameworks");
+        println!("cargo:rustc-link-lib=framework=Security");
+    }
+
+    let bindings = bindgen::Builder::default()
+        .clang_args(vec![
+            "-I",
+            "../../include",
+            "-I",
+            &format!("{}/build", dst.display()),
+        ])
+        .header("wrapper.h")
+        .prepend_enum_name(false)
+        .whitelist_recursively(true)
+        // C stdlib types that we want to get from the libc crate
+        .blacklist_type("FILE")
+        .blacklist_type("addrinfo")
+        .blacklist_type("timespec")
+        // We provide a custom binding of metric with atomic types
+        .blacklist_type("metric")
+        // All public types, variables and, functions exported by ccommon
+        .whitelist_type("u?intmax_t")
+        .whitelist_type("u?int([0-9]+)_t")
+        .whitelist_type("cc_.*")
+        .whitelist_function("cc_.*")
+        .whitelist_var("CC_.*")
+        .whitelist_function("_cc_.*")
+        .whitelist_type("rstatus_i")
+        .whitelist_type("err_i")
+        .whitelist_type("buf_.*")
+        .whitelist_type("buf")
+        .whitelist_var("BUF_.*")
+        .whitelist_function("buf_.*")
+        .whitelist_type("dbuf_.*")
+        .whitelist_function("dbuf_.*")
+        .whitelist_var("DBUF_.*")
+        .whitelist_type("channel_.*")
+        .whitelist_var("CHANNEL_.*")
+        .whitelist_type("ch_id_i")
+        .whitelist_type("ch_level_e")
+        .whitelist_var("PIPE_.*")
+        .whitelist_type("pipe_.*")
+        .whitelist_function("pipe_.*")
+        .whitelist_var("TCP_.*")
+        .whitelist_type("tcp_.*")
+        .whitelist_function("tcp_.*")
+        .whitelist_function("hash_murmur3_.*")
+        .whitelist_type("log_.*")
+        .whitelist_function("log_.*")
+        .whitelist_var("LOG_.*")
+        .whitelist_type("sockio_.*")
+        .whitelist_function("sockio_.*")
+        .whitelist_type("duration")
+        .whitelist_type("duration_.*")
+        .whitelist_type("timeout")
+        .whitelist_function("duration_.*")
+        .whitelist_function("timeout_.*")
+        .whitelist_type("timing_wheel_.*")
+        .whitelist_type("timing_wheel")
+        .whitelist_function("timing_wheel_.*")
+        .whitelist_type("tevent_tqh")
+        .whitelist_type("timeout_.*")
+        .whitelist_var("NELEM_DELTA")
+        .whitelist_type("array_.*")
+        .whitelist_type("array")
+        .whitelist_function("array_.*")
+        .whitelist_type("bstring")
+        .whitelist_function("bstring_.*")
+        .whitelist_var("DEBUG_.*")
+        .whitelist_type("debug_.*")
+        .whitelist_function("debug_.*")
+        .whitelist_var("dlog")
+        .whitelist_function("_log")
+        .whitelist_function("_log_hexdump")
+        .whitelist_var("EVENT_.*")
+        .whitelist_type("event_.*")
+        .whitelist_function("event_.*")
+        .whitelist_type("logger")
+        .whitelist_type("log_.*")
+        .whitelist_function("log_.*")
+        .whitelist_function("_log_fd")
+        .whitelist_type("metric")
+        .whitelist_type("metric_.*")
+        .whitelist_function("metric_.*")
+        .whitelist_var("OPTLINE_MAXLEN")
+        .whitelist_var("OPTNAME_MAXLEN")
+        .whitelist_var("OPTVAL_MAXLEN")
+        .whitelist_type("option_.*")
+        .whitelist_var("option_.*")
+        .whitelist_type("option")
+        .whitelist_function("option_.*")
+        .whitelist_type("rbuf_.*")
+        .whitelist_type("rbuf")
+        .whitelist_function("rbuf_.*")
+        .whitelist_var("RING_ARRAY_.*")
+        .whitelist_type("ring_array")
+        .whitelist_function("ring_array_.*")
+        .whitelist_type("sig_fn")
+        .whitelist_type("signal")
+        .whitelist_var("signals")
+        .whitelist_function("signal_.*")
+        .whitelist_type("stats_.*")
+        .whitelist_function("stats_.*")
+        .whitelist_type("iobuf_p")
+        .whitelist_type("io_.*")
+        .whitelist_type("stream_.*")
+        .whitelist_type("address_p")
+        .whitelist_var("BUFSOCK_.*")
+        .derive_copy(true)
+        .derive_debug(true)
+        .generate()
+        .expect("Unable to generate bindings");
+
+    bindings
+        .write_to_file("src/bindings.rs")
+        .expect("Couldn't write bindings!");
+
+    let have_working_rustfmt = std::process::Command::new("rustup")
+        .args(&["run", "rustfmt", "--version"])
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .ok()
+        .map_or(false, |status| status.success());
+
+    if !have_working_rustfmt {
+        println!(
+            "
+        The latest `rustfmt` is required to format the generated bindings. Install
+            `rustfmt` with:
+            $ rustup component add rustfmt
+            $ rustup update
+            "
+        );
+    }
+}
diff --git a/rust/ccommon-sys/src/lib.rs b/rust/ccommon-sys/src/lib.rs
new file mode 100644
index 000000000..676824d37
--- /dev/null
+++ b/rust/ccommon-sys/src/lib.rs
@@ -0,0 +1,61 @@
+// ccommon - a cache common library.
+// Copyright (C) 2018 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! This module contains the generated bindings for the `ccommon` library.
+//!
+//! PRO-TIP: To view the generated code, look in `src/bindings.rs` after running
+//! the build.
+
+#![allow(
+    unknown_lints,
+    clippy::all,
+    non_upper_case_globals,
+    non_camel_case_types,
+    non_snake_case,
+    dead_code
+)]
+
+#[path = "metric.rs"]
+mod metric_impl;
+
+pub use metric_impl::{metric, metric_anon_union};
+
+use libc::{addrinfo, timespec, FILE};
+
+include!("bindings.rs");
+
+pub const DEBUG_LOG_FILE: *mut i8 = std::ptr::null_mut();
+
+/// default log file
+pub const STATS_LOG_FILE: *mut i8 = std::ptr::null_mut();
+/// default log buf size
+pub const STATS_LOG_NBUF: u32 = 0;
+
+// Option methods
+pub unsafe fn option_bool(opt: *mut option) -> bool {
+    return (*opt).val.vbool;
+}
+
+pub unsafe fn option_uint(opt: *mut option) -> u64 {
+    return (*opt).val.vuint;
+}
+
+pub unsafe fn option_fpn(opt: *mut option) -> f64 {
+    return (*opt).val.vfpn;
+}
+
+pub unsafe fn option_str(opt: *mut option) -> *mut i8 {
+    return (*opt).val.vstr;
+}
diff --git a/rust/ccommon-sys/src/metric.rs b/rust/ccommon-sys/src/metric.rs
new file mode 100644
index 000000000..bd50002ef
--- /dev/null
+++ b/rust/ccommon-sys/src/metric.rs
@@ -0,0 +1,99 @@
+// ccommon - a cache common library.
+// Copyright (C) 2019 Twitter, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::mem::{align_of, size_of, MaybeUninit};
+use std::os::raw::c_char;
+
+use crate::metric_type_e;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct metric {
+    pub name: *mut c_char,
+    pub desc: *mut c_char,
+    pub type_: metric_type_e,
+    pub data: metric_anon_union,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union metric_anon_union {
+    bytes: [MaybeUninit<u8>; size_of::<u64>()],
+    _align: u64,
+}
+
+impl metric_anon_union {
+    pub unsafe fn as_ptr<T>(&self) -> *const T {
+        assert!(align_of::<T>() <= align_of::<Self>());
+        assert!(size_of::<T>() <= size_of::<Self>());
+
+        (&self.bytes).align_to().1.as_ptr()
+    }
+
+    pub unsafe fn as_mut_ptr<T>(&mut self) -> *mut T {
+        assert!(align_of::<T>() <= align_of::<Self>());
+        assert!(size_of::<T>() <= size_of::<Self>());
+
+        (&mut self.bytes).align_to_mut().1.as_mut_ptr()
+    }
+
+    fn uninit() -> Self {
+        Self {
+            bytes: [MaybeUninit::uninit(); size_of::<u64>()],
+        }
+    }
+
+    pub fn counter(val: u64) -> Self {
+        unsafe {
+            let mut x = Self::uninit();
+            std::ptr::write(x.as_mut_ptr(), val);
+            x
+        }
+    }
+
+    pub fn gauge(val: i64) -> Self {
+        unsafe {
+            let mut x = Self::uninit();
+            std::ptr::write(x.as_mut_ptr(), val);
+            x
+        }
+    }
+
+    pub fn fpn(val: f64) -> Self {
+        unsafe {
+            let mut x = Self::uninit();
+            std::ptr::write(x.as_mut_ptr(), val);
+            x
+        }
+    }
+}
+
+#[test]
+fn metric_anon_union_aligment_correct() {
+    assert_eq!(
+        std::mem::align_of::<metric_anon_union>(),
+        std::mem::align_of::<u64>()
+    );
+
+    assert_eq!(
+        std::mem::align_of::<metric_anon_union>(),
+        std::mem::align_of::<i64>()
+    );
+
+    assert_eq!(
+        std::mem::align_of::<metric_anon_union>(),
+        std::mem::align_of::<f64>()
+    );
+}
diff --git a/rust/ccommon-sys/wrapper.h b/rust/ccommon-sys/wrapper.h
new file mode 100644
index 000000000..070b40cf6
--- /dev/null
+++ b/rust/ccommon-sys/wrapper.h
@@ -0,0 +1,51 @@
+/* ccommon - a cache common library.
+ * Copyright (C) 2018 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+#include <rust/cc_log_rs.h>
+
+#include <buffer/cc_buf.h>
+#include <buffer/cc_dbuf.h>
+
+#include <channel/cc_channel.h>
+#include <channel/cc_pipe.h>
+#include <channel/cc_tcp.h>
+
+#include <hash/cc_murmur3.h>
+
+#include <stream/cc_sockio.h>
+
+#include <time/cc_timer.h>
+#include <time/cc_wheel.h>
+
+#include <cc_array.h>
+#include <cc_bstring.h>
+#include <cc_debug.h>
+#include <cc_define.h>
+#include <cc_event.h>
+#include <cc_itt.h>
+#include <cc_log.h>
+#include <cc_metric.h>
+#include <cc_mm.h>
+#include <cc_option.h>
+#include <cc_pool.h>
+#include <cc_print.h>
+#include <cc_queue.h>
+#include <cc_rbuf.h>
+#include <cc_ring_array.h>
+#include <cc_signal.h>
+#include <cc_stats_log.h>
+#include <cc_stream.h>
+#include <cc_util.h>
diff --git a/rust/ccommon_rs/CMakeLists.txt b/rust/ccommon_rs/CMakeLists.txt
deleted file mode 100644
index f373e0938..000000000
--- a/rust/ccommon_rs/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-file(WRITE CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}\n")
-cargo_build(NAME ccommon_rs)
-add_dependencies(ccommon_rs_static ccommon-static)
-add_dependencies(ccommon_rs_shared ccommon-shared)
diff --git a/rust/ccommon_rs/Cargo.toml b/rust/ccommon_rs/Cargo.toml
deleted file mode 100644
index 382bf2286..000000000
--- a/rust/ccommon_rs/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-name = "ccommon_rs"
-version = "0.1.0"
-authors = ["Jonathan Simms <jsimms@twitter.com>"]
-
-[dependencies]
-
-cc_binding = { path = "../cc_binding" }
-
-log = "~0.4"
-libc = "~0.2.42"
-failure = "~0.1.1"
diff --git a/rust/ccommon_rs/src/lib.rs b/rust/ccommon_rs/src/lib.rs
deleted file mode 100644
index 6d035da4d..000000000
--- a/rust/ccommon_rs/src/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-extern crate cc_binding;
-extern crate failure;
-pub mod bstring;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 43828ce17..99582e640 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -19,13 +19,13 @@ set(SOURCE
     cc_ring_array.c
     cc_signal.c)
 
-# targets to build: here we have both static and dynmaic libs
+# targets to build: here we have both static and dynamic libs
 set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
 add_library(${PROJECT_NAME}-static STATIC ${SOURCE})
 add_library(${PROJECT_NAME}-shared SHARED ${SOURCE})
 if (OS_PLATFORM STREQUAL "OS_LINUX")
-  target_link_libraries(${PROJECT_NAME}-static rt)
-  target_link_libraries(${PROJECT_NAME}-shared rt)
+  target_link_libraries(${PROJECT_NAME}-static rt m pthread)
+  target_link_libraries(${PROJECT_NAME}-shared rt m pthread)
 endif(OS_PLATFORM STREQUAL "OS_LINUX")
 set_target_properties(${PROJECT_NAME}-static
     PROPERTIES
diff --git a/src/buffer/cc_buf.c b/src/buffer/cc_buf.c
index 4ac2b12e6..c23404719 100644
--- a/src/buffer/cc_buf.c
+++ b/src/buffer/cc_buf.c
@@ -157,8 +157,8 @@ buf_destroy(struct buf **buf)
         return;
     }
 
-    cap = buf_capacity(*buf);
-    log_verb("destroy buf %p capacity %"PRIu32, *buf, cap);
+    cap = buf_size(*buf);
+    log_verb("destroy buf %p size %"PRIu32, *buf, cap);
 
     cc_free(*buf);
     *buf = NULL;
diff --git a/src/buffer/cc_dbuf.c b/src/buffer/cc_dbuf.c
index db2432210..46ab23341 100644
--- a/src/buffer/cc_dbuf.c
+++ b/src/buffer/cc_dbuf.c
@@ -51,9 +51,15 @@ static rstatus_i
 _dbuf_resize(struct buf **buf, uint32_t nsize)
 {
     struct buf *nbuf;
-    uint32_t osize = buf_size(*buf);
-    uint32_t roffset = (*buf)->rpos - (*buf)->begin;
-    uint32_t woffset = (*buf)->wpos - (*buf)->begin;
+    uint32_t osize, roffset, woffset;
+
+    if (nsize > max_size) {
+        return CC_ERROR;
+    }
+
+    osize = buf_size(*buf);
+    roffset = (*buf)->rpos - (*buf)->begin;
+    woffset = (*buf)->wpos - (*buf)->begin;
 
     nbuf = cc_realloc(*buf, nsize);
     if (nbuf == NULL) { /* realloc failed, but *buf is still valid */
@@ -80,10 +86,6 @@ dbuf_double(struct buf **buf)
     rstatus_i status;
     uint32_t nsize = buf_size(*buf) * 2;
 
-    if (nsize > max_size) {
-        return CC_ERROR;
-    }
-
     status = _dbuf_resize(buf, nsize);
     if (status == CC_OK) {
         INCR(dbuf_metrics, dbuf_double);
@@ -100,12 +102,14 @@ dbuf_fit(struct buf **buf, uint32_t cap)
     rstatus_i status = CC_OK;
     uint32_t nsize = buf_init_size;
 
-    buf_lshift(*buf);
-    if (buf_rsize(*buf) > cap || cap + BUF_HDR_SIZE > max_size) {
+    /* check if new cap can contain unread bytes */
+    if (buf_rsize(*buf) > cap) {
         return CC_ERROR;
     }
 
-    /* cap is checked, given how max_size is initialized this is safe */
+    buf_lshift(*buf);
+
+    /* double size of buf until it can fit cap */
     while (nsize < cap + BUF_HDR_SIZE) {
         nsize *= 2;
     }
@@ -125,9 +129,9 @@ dbuf_fit(struct buf **buf, uint32_t cap)
 rstatus_i
 dbuf_shrink(struct buf **buf)
 {
-    rstatus_i status = CC_OK;
     uint32_t nsize = buf_init_size;
     uint32_t cap = buf_rsize(*buf);
+    rstatus_i status = CC_OK;
 
     buf_lshift(*buf);
 
@@ -136,7 +140,12 @@ dbuf_shrink(struct buf **buf)
     }
 
     if (nsize != buf_size(*buf)) {
+        /*
+         * realloc is not guaranteed to succeed even on trim, but in the case
+         * that it fails, original buf will still be valid.
+         */
         status = _dbuf_resize(buf, nsize);
+
         if (status == CC_OK) {
             INCR(dbuf_metrics, dbuf_shrink);
         } else {
diff --git a/src/cc_array.c b/src/cc_array.c
index 5768ddde6..0832647a1 100644
--- a/src/cc_array.c
+++ b/src/cc_array.c
@@ -74,7 +74,7 @@ array_create(struct array **arr, uint32_t nalloc, size_t size)
     ASSERT(nalloc != 0 && size != 0);
 
     *arr = (struct array *)cc_alloc(sizeof(**arr));
-    if (arr == NULL) {
+    if (*arr == NULL) {
         log_info("array creation failed due to OOM");
 
         return CC_ENOMEM;
diff --git a/src/cc_bstring.c b/src/cc_bstring.c
index 58f40ca24..2d10f64bd 100644
--- a/src/cc_bstring.c
+++ b/src/cc_bstring.c
@@ -20,6 +20,8 @@
 #include <cc_debug.h>
 #include <cc_mm.h>
 
+#include <ctype.h>
+
 /*
  * Byte string (struct bstring) is a sequence of unsigned char
  * The length of the string is pre-computed and explicitly available.
@@ -33,9 +35,9 @@
  * raw sequence of character bytes - bstring_copy(). Such String's must be
  * freed using bstring_deinit()
  *
- * We can also create String as reference to raw string - bstring_set_raw()
- * or to string literal - bstring_set_text() or bstring(). Such bstrings don't
- * have to be freed.
+ * We can also create String as reference to C string - bstring_set_cstr()
+ * or to string literal - bstring_set_literal() or bstring(). Such bstrings
+ * don't have to be freed.
  */
 
 void
@@ -113,6 +115,46 @@ bstring_compare(const struct bstring *s1, const struct bstring *s2)
     return cc_bcmp(s1->data, s2->data, s1->len);
 }
 
+rstatus_i
+bstring_atoi64(int64_t *i64, struct bstring *str)
+{
+    uint32_t offset = 0;
+    uint8_t c;
+    int64_t sign = 1;
+
+    if (str->len == 0 || str->len >= CC_INT64_MAXLEN) {
+        return CC_ERROR;
+    }
+
+    if (*str->data == '-') {
+        offset = 1;
+        sign = -1;
+    }
+
+    for (*i64 = 0LL; offset < str->len; offset++) {
+        c = *(str->data + offset);
+        if (isdigit(c) == 0) {
+            return CC_ERROR;
+        }
+
+        // overflow check
+        if (offset == CC_INT64_MAXLEN - 2) {
+            if (sign < 0 && *i64 == INT64_MIN / 10 &&
+                    c - '0' > -(INT64_MIN % 10)) {
+                return CC_ERROR;
+            }
+            if (sign > 0 && *i64 == INT64_MAX / 10 &&
+                    c - '0' > INT64_MAX % 10) {
+                return CC_ERROR;
+            }
+        }
+
+        *i64 = *i64 * 10LL + sign * (int64_t)(c - '0');
+    }
+
+    return CC_OK;
+}
+
 rstatus_i
 bstring_atou64(uint64_t *u64, struct bstring *str)
 {
@@ -127,7 +169,7 @@ bstring_atou64(uint64_t *u64, struct bstring *str)
 
     for (offset = 0; offset < str->len; offset++) {
         c = *(str->data + offset);
-        if (c < '0' || c > '9') {
+        if (isdigit(c) == 0) {
             return CC_ERROR;
         }
 
diff --git a/src/cc_debug.c b/src/cc_debug.c
index 7c766260b..7db49a7aa 100644
--- a/src/cc_debug.c
+++ b/src/cc_debug.c
@@ -20,7 +20,6 @@
 #include <cc_log.h>
 #include <cc_mm.h>
 #include <cc_print.h>
-#include <time/cc_wheel.h>
 
 #include <ctype.h>
 #include <errno.h>
@@ -32,10 +31,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#include <pthread.h>
 
 #define BACKTRACE_DEPTH 64
 #define DEBUG_MODULE_NAME "ccommon::debug"
 
+
 struct debug_logger default_logger;
 struct debug_logger *dlog = &default_logger;
 static bool debug_init = false;
@@ -50,6 +51,18 @@ static char * level_str[] = {
     "VVERB"
 };
 
+static char tname_buf[16];
+
+static inline char *
+_thread_name(void)
+{
+    /* we do not expect the following to fail ever, because buffer is sufficiently long */
+    pthread_getname_np(pthread_self(), tname_buf, 16);
+
+    return tname_buf;
+}
+
+
 static void
 debug_stacktrace(int skip_count)
 {
@@ -73,13 +86,17 @@ debug_stacktrace(int skip_count)
     }
 
     free(symbols);
+
+    /* when segfault happens, currently it will loop printing
+     * stack trace forever, add abort to stop this */
+    abort();
 #endif
 }
 
 void
 debug_assert(const char *cond, const char *file, int line, int panic)
 {
-    log_stderr("assert '%s' failed @ (%s, %d)", cond, file, line);
+    log_stderr("[%s] assert '%s' failed @ (%s, %d)", _thread_name(), cond, file, line);
     if (panic) {
         debug_stacktrace(1);
         abort();
@@ -199,8 +216,8 @@ _log(struct debug_logger *dl, const char *file, int line, int level, const char
     local = localtime(&t);
     timestr = asctime(local);
 
-    len += cc_scnprintf(buf + len, size - len, "[%.*s][%s] %s:%d ",
-            strlen(timestr) - 1, timestr, level_str[level], file, line);
+    len += cc_scnprintf(buf + len, size - len, "[%.*s][%s][%s] %s:%d ",
+            strlen(timestr) - 1, timestr, _thread_name(), level_str[level], file, line);
 
     va_start(args, fmt);
     len += cc_vscnprintf(buf + len, size - len, fmt, args);
diff --git a/src/cc_log.c b/src/cc_log.c
index c97979d0d..da013e061 100644
--- a/src/cc_log.c
+++ b/src/cc_log.c
@@ -18,6 +18,7 @@
 #include <cc_log.h>
 
 #include <cc_mm.h>
+#include <cc_pool.h>
 #include <cc_print.h>
 #include <cc_rbuf.h>
 #include <cc_util.h>
@@ -37,6 +38,30 @@
 static log_metrics_st *log_metrics = NULL;
 static bool log_init = false;
 
+/* this function is called from rust so that it can use log_setup */
+log_metrics_st *
+log_metrics_create()
+{
+    log_metrics_st *metrics = cc_alloc(sizeof(log_metrics_st));
+    if (metrics == NULL) {
+        log_panic("Failed to allocate log_metrics_st");
+    }
+    log_metrics_st mtr = (log_metrics_st) { LOG_METRIC(METRIC_INIT) };
+    memcpy(metrics, &mtr, sizeof(mtr));
+    return metrics;
+}
+
+void
+log_metrics_destroy(log_metrics_st **m)
+{
+    if (m == NULL) {
+        log_panic("pointer passed to log_destroy_metrics was null");
+    }
+
+    cc_free(*m);
+    *m = NULL;
+}
+
 void
 log_setup(log_metrics_st *metrics)
 {
diff --git a/src/cc_mm.c b/src/cc_mm.c
index 6a0554289..8fa28f980 100644
--- a/src/cc_mm.c
+++ b/src/cc_mm.c
@@ -24,9 +24,12 @@
 #include <string.h>
 #include <sys/mman.h>
 
-/* TODO(yao): detect OS in one place and use one variable everywhere */
-#if defined(__APPLE__) && defined(__MACH__)
+#ifdef OS_DARWIN
 #   define MAP_ANONYMOUS MAP_ANON
+#include <malloc/malloc.h>
+#define malloc_usable_size malloc_size
+#else
+#include <malloc.h>
 #endif
 
 void *
@@ -167,3 +170,10 @@ _cc_munmap(void *p, size_t size, const char *name, int line)
 
     return status;
 }
+
+size_t
+_cc_alloc_usable_size(void *ptr, const char *name, int line)
+{
+    log_vverb("malloc_usable_size(%p) @ %s:%d", ptr, name, line);
+    return malloc_usable_size(ptr);
+}
diff --git a/src/cc_option.c b/src/cc_option.c
index 2a18fbf4c..330463760 100644
--- a/src/cc_option.c
+++ b/src/cc_option.c
@@ -441,8 +441,7 @@ static inline bool
 _allowed_in_name(char c)
 {
     /* the criteria is C's rules on variable names since we use it as such */
-    if ((c >= 'a' && c <= 'z') || c == '_' || (c >= 'A' && c <= 'Z') ||
-        (c >= '0' && c <= '9')) {
+    if (isalnum(c) || c == '_') {
         return true;
     } else {
         return false;
diff --git a/src/cc_ring_array.c b/src/cc_ring_array.c
index 0d423d931..4b3dc80db 100644
--- a/src/cc_ring_array.c
+++ b/src/cc_ring_array.c
@@ -172,13 +172,13 @@ ring_array_create(size_t elem_size, uint32_t cap)
 void
 ring_array_destroy(struct ring_array **arr)
 {
-    log_verb("destroying ring array %p and freeing memory", *arr);
-
     if ((arr == NULL) || (*arr == NULL)) {
         log_warn("destroying NULL ring_array pointer");
         return;
     }
 
+    log_verb("destroying ring array %p and freeing memory", *arr);
+
     cc_free(*arr);
     *arr = NULL;
 }
diff --git a/src/channel/cc_tcp.c b/src/channel/cc_tcp.c
index d482ac9c0..2129d9277 100644
--- a/src/channel/cc_tcp.c
+++ b/src/channel/cc_tcp.c
@@ -18,6 +18,7 @@
 #include <channel/cc_tcp.h>
 
 #include <cc_debug.h>
+#include <cc_define.h>
 #include <cc_mm.h>
 #include <cc_pool.h>
 #include <cc_util.h>
@@ -281,6 +282,12 @@ tcp_listen(struct addrinfo *ai, struct tcp_conn *c)
         goto error;
     }
 
+    ret = tcp_set_tcpnodelay(sd);
+    if (ret < 0) {
+        log_warn("set tcp nodelay on listening sd %d failed, ignored: %s", sd,
+                 strerror(errno));
+    }
+
     c->level = CHANNEL_META;
     c->state = CHANNEL_LISTEN;
     log_info("server listen setup on socket descriptor %d", c->sd);
@@ -318,29 +325,63 @@ _tcp_accept(struct tcp_conn *sc)
 {
     int sd;
 
-    ASSERT(sc->sd > 0);
-
-    for (;;) { /* we accept at most one tcp_conn with the 'break' at the end */
+    ASSERT(sc->sd >= 0);
+
+    /* How does tcp accept work when a separate thread is used to accept new
+     * connections?
+     *
+     * In general, we want to accept a new connection at a time (on the server
+     * thread), then hand this connection over to be put on some other event
+     * loop (e.g. on a worker thread's), and some additional preparation may
+     * be necessary (e.g. allocating R/W buffers). This is why we break after
+     * completing a single `accept' successfully.
+     *
+     * There are several ways `accept' could "fail", and they need to be
+     * treated differently. The most common case, which isn't really a failure
+     * on a non-blocking socket, is receiving EAGAIN/EWOULDBLOCK. This simply
+     * means there is no new connection to accept and the function should
+     * return.
+     * EINTR is another common error which means the call was terminated by
+     * a signal. This type of interruption is almost always transient, so
+     * an immediate retry is likely to succeed.
+     * The rest of the exceptions likely to occur on a SOCK_STREAM socket are
+     * often due to exhaustion of some resources (e.g. fd, memory), and there
+     * is no guarantee they will recover immediately. For example, to free
+     * up another fd requires an existing connection to be closed. In such
+     * cases, the connection in the backlog will sit there (as fully
+     * established as far as TCP stack is concerned) until accept in application
+     * becomes possible again, and any new connections arriving will be added
+     * to the back of the queue until it's full, at which point the client
+     * will receive an exception and the connect attempt will fail.
+     */
+    for (;;) {
+#ifdef CC_ACCEPT4
+        sd = accept4(sc->sd, NULL, NULL, SOCK_NONBLOCK);
+#else
         sd = accept(sc->sd, NULL, NULL);
+#endif /* CC_ACCEPT4 */
         if (sd < 0) {
-            if (errno == EINTR) {
-                log_debug("accept on sd %d not ready: eintr", sc->sd);
-                continue;
-            }
-
             if (errno == EAGAIN || errno == EWOULDBLOCK) {
                 log_debug("accept on sd %d not ready: eagain", sc->sd);
                 return -1;
             }
 
+            if (errno == EINTR) {
+                log_debug("accept on sd %d not ready: eintr", sc->sd);
+
+                continue;
+            }
+
             log_error("accept on sd %d failed: %s", sc->sd, strerror(errno));
             INCR(tcp_metrics, tcp_accept_ex);
+
             return -1;
         }
 
         break;
     }
 
+    ASSERT(sd >= 0);
     return sd;
 }
 
@@ -360,17 +401,13 @@ tcp_accept(struct tcp_conn *sc, struct tcp_conn *c)
     c->level = CHANNEL_BASE;
     c->state = CHANNEL_ESTABLISHED;
 
+#ifndef CC_ACCEPT4 /* if we have accept4, nonblock will already have been set */
     ret = tcp_set_nonblocking(sd);
     if (ret < 0) {
         log_warn("set nonblock on sd %d failed, ignored: %s", sd,
                 strerror(errno));
     }
-
-    ret = tcp_set_tcpnodelay(sd);
-    if (ret < 0) {
-        log_warn("set tcp nodelay on sd %d failed, ignored: %s", sd,
-                 strerror(errno));
-    }
+#endif
 
     log_info("accepted c %d on sd %d", c->sd, sc->sd);
 
@@ -416,18 +453,20 @@ tcp_reject_all(struct tcp_conn *sc)
     for (;;) {
         sd = accept(sc->sd, NULL, NULL);
         if (sd < 0) {
-            if (errno == EINTR) {
-                log_debug("sd %d not ready: eintr", sc->sd);
-                continue;
-            }
-
             if (errno == EAGAIN || errno == EWOULDBLOCK) {
                 log_debug("sd %d has no more outstanding connections", sc->sd);
                 return;
             }
 
+            if (errno == EINTR) {
+                log_debug("accept on sd %d not ready: eintr", sc->sd);
+
+                continue;
+            }
+
             log_error("accept on sd %d failed: %s", sc->sd, strerror(errno));
             INCR(tcp_metrics, tcp_reject_ex);
+
             return;
         }
 
diff --git a/src/event/cc_epoll.c b/src/event/cc_epoll.c
index f8455d32b..25dbdaeb6 100644
--- a/src/event/cc_epoll.c
+++ b/src/event/cc_epoll.c
@@ -57,9 +57,9 @@ event_base_create(int nevent, event_cb_fn cb)
 
     ASSERT(nevent > 0);
 
-    ep = epoll_create(nevent);
+    ep = epoll_create1(0);
     if (ep < 0) {
-        log_error("epoll create size %d failed: %s", nevent, strerror(errno));
+        log_error("epoll create1 failed: %s", strerror(errno));
         return NULL;
     }
 
@@ -122,9 +122,6 @@ _event_update(struct event_base *evb, int fd, int op, uint32_t events, void *ptr
 {
     struct epoll_event event;
 
-    ASSERT(evb != NULL && evb->ep > 0);
-    ASSERT(fd > 0);
-
     event.events = events;
     event.data.ptr = ptr;
 
@@ -135,6 +132,9 @@ int event_add_read(struct event_base *evb, int fd, void *data)
 {
     int status;
 
+    ASSERT(evb != NULL && evb->ep > 0);
+    ASSERT(fd >= 0);
+
     /*
      * Note(yao): there have been tests showing EPOLL_CTL_ADD is cheaper than
      * EPOLL_CTL_MOD, and the only difference is we need to ignore EEXIST
@@ -156,6 +156,9 @@ event_add_write(struct event_base *evb, int fd, void *data)
 {
     int status;
 
+    ASSERT(evb != NULL && evb->ep > 0);
+    ASSERT(fd >= 0);
+
     status = _event_update(evb, fd, EPOLL_CTL_ADD, EPOLLOUT, data);
     if (status < 0 && errno != EEXIST) {
         log_error("ctl (add write) w/ epoll fd %d on fd %d failed: %s", evb->ep,
@@ -173,6 +176,9 @@ event_del(struct event_base *evb, int fd)
 {
     int status;
 
+    ASSERT(evb != NULL && evb->ep > 0);
+    ASSERT(fd >= 0);
+
     /* event can be NULL in kernel >=2.6.9, here we keep it for compatibility */
     status = _event_update(evb, fd, EPOLL_CTL_DEL, 0, NULL);
     if (status < 0) {
diff --git a/src/hash/CMakeLists.txt b/src/hash/CMakeLists.txt
index 60f178c00..f8a54fde2 100644
--- a/src/hash/CMakeLists.txt
+++ b/src/hash/CMakeLists.txt
@@ -1,5 +1,4 @@
 set(SOURCE
     ${SOURCE}
-    hash/cc_lookup3.c
     hash/cc_murmur3.c
     PARENT_SCOPE)
diff --git a/src/hash/cc_lookup3.c b/src/hash/cc_lookup3.c
deleted file mode 100644
index cef9b1186..000000000
--- a/src/hash/cc_lookup3.c
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * ccommon - a cache common library.
- * Copyright (C) 2013 Twitter, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- * Hash table
- *
- * The hash function used here is by Bob Jenkins, 1996:
- *   <http://burtleburtle.net/bob/hash/doobs.html>
- *   "By Bob Jenkins, 1996.  bob_jenkins@burtleburtle.net.
- *   You may use this code any way you wish, private, educational,
- *   or commercial.  It's free."
- *
- */
-
-/*
- * Since the hash function does bit manipulation, it needs to know
- * whether it's big or little-endian. HAVE_LITTLE_ENDIAN and HAVE_BIG_ENDIAN
- * are set in the configure script.
- */
-#include <hash/cc_lookup3.h>
-
-#if defined CC_BIG_ENDIAN && CC_BIG_ENDIAN == 1
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN    1
-#elif defined CC_LITTLE_ENDIAN && CC_LITTLE_ENDIAN == 1
-# define HASH_LITTLE_ENDIAN 1
-# define HASH_BIG_ENDIAN    0
-#else
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN    0
-#endif
-
-#define rot(x,k) (((x)<<(k)) ^ ((x)>>(32-(k))))
-
-/*
--------------------------------------------------------------------------------
-mix -- mix 3 32-bit values reversibly.
-
-This is reversible, so any information in (a,b,c) before mix() is
-still in (a,b,c) after mix().
-
-If four pairs of (a,b,c) inputs are run through mix(), or through
-mix() in reverse, there are at least 32 bits of the output that
-are sometimes the same for one pair and different for another pair.
-This was tested for:
-* pairs that differed by one bit, by two bits, in any combination
-  of top bits of (a,b,c), or in any combination of bottom bits of
-  (a,b,c).
-* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
-  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
-  is commonly produced by subtraction) look like a single 1-bit
-  difference.
-* the base values were pseudorandom, all zero but one bit set, or
-  all zero plus a counter that starts at zero.
-
-Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
-satisfy this are
-    4  6  8 16 19  4
-    9 15  3 18 27 15
-   14  9  3  7 17  3
-Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
-for "differ" defined as + with a one-bit base and a two-bit delta.  I
-used http://burtleburtle.net/bob/hash/avalanche.html to choose
-the operations, constants, and arrangements of the variables.
-
-This does not achieve avalanche.  There are input bits of (a,b,c)
-that fail to affect some output bits of (a,b,c), especially of a.  The
-most thoroughly mixed value is c, but it doesn't really even achieve
-avalanche in c.
-
-This allows some parallelism.  Read-after-writes are good at doubling
-the number of bits affected, so the goal of mixing pulls in the opposite
-direction as the goal of parallelism.  I did what I could.  Rotates
-seem to cost as much as shifts on every machine I could lay my hands
-on, and rotates are much kinder to the top and bottom bits, so I used
-rotates.
--------------------------------------------------------------------------------
-*/
-#define mix(a,b,c) \
-{ \
-  a -= c;  a ^= rot(c, 4);  c += b; \
-  b -= a;  b ^= rot(a, 6);  a += c; \
-  c -= b;  c ^= rot(b, 8);  b += a; \
-  a -= c;  a ^= rot(c,16);  c += b; \
-  b -= a;  b ^= rot(a,19);  a += c; \
-  c -= b;  c ^= rot(b, 4);  b += a; \
-}
-
-/*
--------------------------------------------------------------------------------
-final -- final mixing of 3 32-bit values (a,b,c) into c
-
-Pairs of (a,b,c) values differing in only a few bits will usually
-produce values of c that look totally different.  This was tested for
-* pairs that differed by one bit, by two bits, in any combination
-  of top bits of (a,b,c), or in any combination of bottom bits of
-  (a,b,c).
-* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
-  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
-  is commonly produced by subtraction) look like a single 1-bit
-  difference.
-* the base values were pseudorandom, all zero but one bit set, or
-  all zero plus a counter that starts at zero.
-
-These constants passed:
- 14 11 25 16 4 14 24
- 12 14 25 16 4 14 24
-and these came close:
-  4  8 15 26 3 22 24
- 10  8 15 26 3 22 24
- 11  8 15 26 3 22 24
--------------------------------------------------------------------------------
-*/
-#define final(a,b,c) \
-{ \
-  c ^= b; c -= rot(b,14); \
-  a ^= c; a -= rot(c,11); \
-  b ^= a; b -= rot(a,25); \
-  c ^= b; c -= rot(b,16); \
-  a ^= c; a -= rot(c,4);  \
-  b ^= a; b -= rot(a,14); \
-  c ^= b; c -= rot(b,24); \
-}
-
-#if HASH_LITTLE_ENDIAN == 1
-uint32_t hash_lookup3(
-  const void *key,       /* the key to hash */
-  size_t      length,    /* length of the key */
-  const uint32_t    initval)   /* initval */
-{
-  uint32_t a,b,c;                                          /* internal state */
-  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
-
-  /* Set up the internal state */
-  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
-
-  u.ptr = key;
-  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
-    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
-#ifdef VALGRIND
-    const uint8_t  *k8;
-#endif /* ifdef VALGRIND */
-
-    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += k[0];
-      b += k[1];
-      c += k[2];
-      mix(a,b,c);
-      length -= 12;
-      k += 3;
-    }
-
-    /*----------------------------- handle the last (probably partial) block */
-    /*
-     * "k[2]&0xffffff" actually reads beyond the end of the string, but
-     * then masks off the part it's not allowed to read.  Because the
-     * string is aligned, the masked-off tail is in the same word as the
-     * rest of the string.  Every machine with memory protection I've seen
-     * does it on word boundaries, so is OK with this.  But VALGRIND will
-     * still catch it and complain.  The masking trick does make the hash
-     * noticably faster for short strings (like English words).
-     */
-#ifndef VALGRIND
-
-    switch(length)
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
-    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
-    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
-    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
-    case 5 : b+=k[1]&0xff; a+=k[0]; break;
-    case 4 : a+=k[0]; break;
-    case 3 : a+=k[0]&0xffffff; break;
-    case 2 : a+=k[0]&0xffff; break;
-    case 1 : a+=k[0]&0xff; break;
-    case 0 : return c;  /* zero length strings require no mixing */
-    }
-
-#else /* make valgrind happy */
-
-    k8 = (const uint8_t *)k;
-    switch(length)
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
-    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
-    case 9 : c+=k8[8];                   /* fall through */
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
-    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
-    case 5 : b+=k8[4];                   /* fall through */
-    case 4 : a+=k[0]; break;
-    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
-    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
-    case 1 : a+=k8[0]; break;
-    case 0 : return c;  /* zero length strings require no mixing */
-    }
-
-#endif /* !valgrind */
-
-  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
-    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
-    const uint8_t  *k8;
-
-    /*--------------- all but last block: aligned reads and different mixing */
-    while (length > 12)
-    {
-      a += k[0] + (((uint32_t)k[1])<<16);
-      b += k[2] + (((uint32_t)k[3])<<16);
-      c += k[4] + (((uint32_t)k[5])<<16);
-      mix(a,b,c);
-      length -= 12;
-      k += 6;
-    }
-
-    /*----------------------------- handle the last (probably partial) block */
-    k8 = (const uint8_t *)k;
-    switch(length)
-    {
-    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
-             b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 11: c+=((uint32_t)k8[10])<<16;     /* @fallthrough */
-    case 10: c+=k[4];                       /* @fallthrough@ */
-             b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 9 : c+=k8[8];                      /* @fallthrough */
-    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 7 : b+=((uint32_t)k8[6])<<16;      /* @fallthrough */
-    case 6 : b+=k[2];
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 5 : b+=k8[4];                      /* @fallthrough */
-    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 3 : a+=((uint32_t)k8[2])<<16;      /* @fallthrough */
-    case 2 : a+=k[0];
-             break;
-    case 1 : a+=k8[0];
-             break;
-    case 0 : return c;  /* zero length strings require no mixing */
-    }
-
-  } else {                        /* need to read the key one byte at a time */
-    const uint8_t *k = (const uint8_t *)key;
-
-    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += k[0];
-      a += ((uint32_t)k[1])<<8;
-      a += ((uint32_t)k[2])<<16;
-      a += ((uint32_t)k[3])<<24;
-      b += k[4];
-      b += ((uint32_t)k[5])<<8;
-      b += ((uint32_t)k[6])<<16;
-      b += ((uint32_t)k[7])<<24;
-      c += k[8];
-      c += ((uint32_t)k[9])<<8;
-      c += ((uint32_t)k[10])<<16;
-      c += ((uint32_t)k[11])<<24;
-      mix(a,b,c);
-      length -= 12;
-      k += 12;
-    }
-
-    /*-------------------------------- last block: affect all 32 bits of (c) */
-    switch(length)                   /* all the case statements fall through */
-    {
-    case 12: c+=((uint32_t)k[11])<<24;
-    case 11: c+=((uint32_t)k[10])<<16;
-    case 10: c+=((uint32_t)k[9])<<8;
-    case 9 : c+=k[8];
-    case 8 : b+=((uint32_t)k[7])<<24;
-    case 7 : b+=((uint32_t)k[6])<<16;
-    case 6 : b+=((uint32_t)k[5])<<8;
-    case 5 : b+=k[4];
-    case 4 : a+=((uint32_t)k[3])<<24;
-    case 3 : a+=((uint32_t)k[2])<<16;
-    case 2 : a+=((uint32_t)k[1])<<8;
-    case 1 : a+=k[0];
-             break;
-    case 0 : return c;  /* zero length strings require no mixing */
-    }
-  }
-
-  final(a,b,c);
-  return c;             /* zero length strings require no mixing */
-}
-
-#elif HASH_BIG_ENDIAN == 1
-/*
- * hashbig():
- * This is the same as hashword() on big-endian machines.  It is different
- * from hashlittle() on all machines.  hashbig() takes advantage of
- * big-endian byte ordering.
- */
-uint32_t hash_lookup3( const void *key, size_t length, const uint32_t initval)
-{
-  uint32_t a,b,c;
-  union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
-
-  /* Set up the internal state */
-  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
-
-  u.ptr = key;
-  if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
-    const uint32_t *k = key;                           /* read 32-bit chunks */
-#ifdef VALGRIND
-    const uint8_t  *k8;
-#endif /* ifdef VALGRIND */
-
-    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += k[0];
-      b += k[1];
-      c += k[2];
-      mix(a,b,c);
-      length -= 12;
-      k += 3;
-    }
-
-    /*----------------------------- handle the last (probably partial) block */
-    /*
-     * "k[2]<<8" actually reads beyond the end of the string, but
-     * then shifts out the part it's not allowed to read.  Because the
-     * string is aligned, the illegal read is in the same word as the
-     * rest of the string.  Every machine with memory protection I've seen
-     * does it on word boundaries, so is OK with this.  But VALGRIND will
-     * still catch it and complain.  The masking trick does make the hash
-     * noticably faster for short strings (like English words).
-     */
-#ifndef VALGRIND
-
-    switch(length)
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
-    case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
-    case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
-    case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
-    case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
-    case 4 : a+=k[0]; break;
-    case 3 : a+=k[0]&0xffffff00; break;
-    case 2 : a+=k[0]&0xffff0000; break;
-    case 1 : a+=k[0]&0xff000000; break;
-    case 0 : return c;              /* zero length strings require no mixing */
-    }
-
-#else  /* make valgrind happy */
-
-    k8 = (const uint8_t *)k;
-    switch(length)                   /* all the case statements fall through */
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=((uint32_t)k8[10])<<8;  /* fall through */
-    case 10: c+=((uint32_t)k8[9])<<16;  /* fall through */
-    case 9 : c+=((uint32_t)k8[8])<<24;  /* fall through */
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=((uint32_t)k8[6])<<8;   /* fall through */
-    case 6 : b+=((uint32_t)k8[5])<<16;  /* fall through */
-    case 5 : b+=((uint32_t)k8[4])<<24;  /* fall through */
-    case 4 : a+=k[0]; break;
-    case 3 : a+=((uint32_t)k8[2])<<8;   /* fall through */
-    case 2 : a+=((uint32_t)k8[1])<<16;  /* fall through */
-    case 1 : a+=((uint32_t)k8[0])<<24; break;
-    case 0 : return c;
-    }
-
-#endif /* !VALGRIND */
-
-  } else {                        /* need to read the key one byte at a time */
-    const uint8_t *k = key;
-
-    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += ((uint32_t)k[0])<<24;
-      a += ((uint32_t)k[1])<<16;
-      a += ((uint32_t)k[2])<<8;
-      a += ((uint32_t)k[3]);
-      b += ((uint32_t)k[4])<<24;
-      b += ((uint32_t)k[5])<<16;
-      b += ((uint32_t)k[6])<<8;
-      b += ((uint32_t)k[7]);
-      c += ((uint32_t)k[8])<<24;
-      c += ((uint32_t)k[9])<<16;
-      c += ((uint32_t)k[10])<<8;
-      c += ((uint32_t)k[11]);
-      mix(a,b,c);
-      length -= 12;
-      k += 12;
-    }
-
-    /*-------------------------------- last block: affect all 32 bits of (c) */
-    switch(length)                   /* all the case statements fall through */
-    {
-    case 12: c+=k[11];
-    case 11: c+=((uint32_t)k[10])<<8;
-    case 10: c+=((uint32_t)k[9])<<16;
-    case 9 : c+=((uint32_t)k[8])<<24;
-    case 8 : b+=k[7];
-    case 7 : b+=((uint32_t)k[6])<<8;
-    case 6 : b+=((uint32_t)k[5])<<16;
-    case 5 : b+=((uint32_t)k[4])<<24;
-    case 4 : a+=k[3];
-    case 3 : a+=((uint32_t)k[2])<<8;
-    case 2 : a+=((uint32_t)k[1])<<16;
-    case 1 : a+=((uint32_t)k[0])<<24;
-             break;
-    case 0 : return c;
-    }
-  }
-
-  final(a,b,c);
-  return c;
-}
-#else /* HASH_XXX_ENDIAN == 1 */
-#error Must define HASH_BIG_ENDIAN or HASH_LITTLE_ENDIAN
-#endif /* HASH_XXX_ENDIAN == 1 */
diff --git a/src/stats/CMakeLists.txt b/src/stats/CMakeLists.txt
index c18ad18f0..3ab1b0ea3 100644
--- a/src/stats/CMakeLists.txt
+++ b/src/stats/CMakeLists.txt
@@ -1,4 +1,5 @@
 set(SOURCE
     ${SOURCE}
     stats/cc_metric.c
+    stats/cc_stats_log.c
     PARENT_SCOPE)
diff --git a/src/stats/cc_stats_log.c b/src/stats/cc_stats_log.c
new file mode 100644
index 000000000..928cd32be
--- /dev/null
+++ b/src/stats/cc_stats_log.c
@@ -0,0 +1,89 @@
+#include <cc_stats_log.h>
+
+#include <cc_debug.h>
+#include <cc_log.h>
+#include <cc_metric.h>
+
+#define STATS_LOG_MODULE_NAME "util::stats_log"
+#define STATS_LOG_FMT "%s: %s, "
+#define PRINT_BUF_LEN 64
+
+static struct logger *slog = NULL;
+static bool stats_log_init = false;
+
+static char buf[PRINT_BUF_LEN];
+
+
+void
+stats_log_setup(stats_log_options_st *options)
+{
+    size_t log_nbuf = STATS_LOG_NBUF;
+    char *filename = STATS_LOG_FILE;
+
+    log_info("set up the %s module", STATS_LOG_MODULE_NAME);
+
+    if (stats_log_init) {
+        log_warn("%s has already been setup, overwrite", STATS_LOG_MODULE_NAME);
+        if (slog != NULL) {
+            log_destroy(&slog);
+        }
+    }
+
+    if (options != NULL) {
+        filename = option_str(&options->stats_log_file);
+        log_nbuf = option_uint(&options->stats_log_nbuf);
+    }
+
+    if (filename != NULL) {
+        slog = log_create(filename, log_nbuf);
+        if (slog == NULL) {
+            log_warn("Could not create logger");
+        }
+    }
+
+    stats_log_init = true;
+}
+
+void
+stats_log_teardown(void)
+{
+    log_info("tear down the %s module", STATS_LOG_MODULE_NAME);
+
+    if (!stats_log_init) {
+        log_warn("%s has never been setup", STATS_LOG_MODULE_NAME);
+    }
+
+    if (slog != NULL) {
+        log_destroy(&slog);
+    }
+
+    stats_log_init = false;
+}
+
+void
+stats_log(struct metric metrics[], unsigned int nmetric)
+{
+    unsigned int i;
+
+    if (slog == NULL) {
+        return;
+    }
+
+    for (i = 0; i < nmetric; i++, metrics++) {
+        int len = 0;
+
+        len = metric_print(buf, PRINT_BUF_LEN, STATS_LOG_FMT, metrics);
+        log_write(slog, buf, len);
+    }
+    log_write(slog, CRLF, CRLF_LEN);
+}
+
+void
+stats_log_flush(void)
+{
+    if (slog == NULL) {
+        return;
+    }
+    log_flush(slog);
+}
+
diff --git a/src/time/cc_timer_darwin.c b/src/time/cc_timer_darwin.c
index 3127643be..a6c4110b1 100644
--- a/src/time/cc_timer_darwin.c
+++ b/src/time/cc_timer_darwin.c
@@ -72,6 +72,12 @@ duration_start(struct duration *d)
     d->start = mach_absolute_time();
 }
 
+void
+duration_start_type(struct duration *d, enum duration_type type)
+{
+    duration_start(d);
+}
+
 void
 duration_stop(struct duration *d)
 {
diff --git a/src/time/cc_timer_linux.c b/src/time/cc_timer_linux.c
index 778fedf98..a3f8ba820 100644
--- a/src/time/cc_timer_linux.c
+++ b/src/time/cc_timer_linux.c
@@ -25,24 +25,35 @@
  * CLOCK_REALTIME can be reset when clock has drifted, so it may not always be
  * monotonic, and should be avoided if possible.
  */
+static const clockid_t cid[MAX_DURATION_TYPE] = {
+    [DURATION_PRECISE] =
 #if defined(CLOCK_MONOTONIC_RAW)
-static const clockid_t cid = CLOCK_MONOTONIC_RAW;
+        CLOCK_MONOTONIC_RAW
 #elif defined(CLOCK_MONOTONIC)
-static const clockid_t cid = CLOCK_MONOTONIC;
+        CLOCK_MONOTONIC
 #elif defined(CLOCK_REALTIME)
-static const clockid_t cid = CLOCK_REALTIME;
+        CLOCK_REALTIME
 #else
-static const clockid_t cid = (clockid_t)-1;
+        (clockid_t)-1
 #endif
+,
+#if defined(CLOCK_MONOTONIC)
+        CLOCK_MONOTONIC
+#elif defined(CLOCK_REALTIME)
+        CLOCK_REALTIME
+#else
+        (clockid_t)-1
+#endif
+};
 
 static inline void
-_gettime(struct timespec *ts)
+_gettime(struct timespec *ts, enum duration_type type)
 {
     int ret;
 
-    ASSERT(cid != (clockid_t)-1);
+    ASSERT(cid[type] != (clockid_t)-1);
 
-    ret = clock_gettime(cid, ts);
+    ret = clock_gettime(cid[type], ts);
     if (ret == -1) {
         /*
          * Note(yao): for the purpose of this module, it doesn't make much sense
@@ -73,10 +84,17 @@ duration_reset(struct duration *d)
 
 void
 duration_start(struct duration *d)
+{
+    duration_start_type(d, DURATION_PRECISE);
+}
+
+void
+duration_start_type(struct duration *d, enum duration_type type)
 {
     ASSERT(d != NULL);
 
-    _gettime(&d->start);
+    _gettime(&d->start, type);
+    d->type = type;
     d->started = true;
 }
 
@@ -87,8 +105,9 @@ duration_snapshot(struct duration *s, const struct duration *d)
 
     s->started = true;
     s->start = d->start;
+    s->type = d->type;
     s->stopped = true;
-    _gettime(&s->stop);
+    _gettime(&s->stop, s->type);
 }
 
 void
@@ -96,7 +115,7 @@ duration_stop(struct duration *d)
 {
     ASSERT(d != NULL);
 
-    _gettime(&d->stop);
+    _gettime(&d->stop, d->type);
     d->stopped = true;
 }
 
@@ -153,9 +172,8 @@ _now_ns(void)
 {
     struct timespec now;
 
-    _gettime(&now);
+    _gettime(&now, DURATION_PRECISE);
     return now.tv_sec * NSEC_PER_SEC + now.tv_nsec;
-
 }
 
 void
diff --git a/test-coverage.sh b/test-coverage.sh
index f6d923818..59c7f0fa5 100755
--- a/test-coverage.sh
+++ b/test-coverage.sh
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 set -e
-rm -rf lcov _build _bin && mkdir _build && pushd _build && cmake -DCOVERAGE=on .. && make -j && make test && popd
+rm -rf lcov _build _bin && mkdir _build && pushd _build && cmake -DCMAKE_BUILD_TYPE=Debug -DCOVERAGE=on .. && make -j && make test && popd
 mkdir lcov
 lcov --directory . --capture --output-file lcov/app.info
 genhtml lcov/app.info -o lcov/html
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 388d3948f..e291873cf 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,9 +1,8 @@
-include_directories(${include_directories} CHECK_INCLUDES)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})
+include_directories(${include_directories} ${CHECK_INCLUDES})
 
 add_subdirectory(array)
 add_subdirectory(bstring)
+add_subdirectory(buffer)
 add_subdirectory(channel)
 add_subdirectory(event)
 add_subdirectory(log)
diff --git a/test/array/CMakeLists.txt b/test/array/CMakeLists.txt
index 41aa3b488..cddb02f59 100644
--- a/test/array/CMakeLists.txt
+++ b/test/array/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/bstring/CMakeLists.txt b/test/bstring/CMakeLists.txt
index 72e4decdb..62d08c6fb 100644
--- a/test/bstring/CMakeLists.txt
+++ b/test/bstring/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/bstring/check_bstring.c b/test/bstring/check_bstring.c
index 352b04398..e35fa61aa 100644
--- a/test/bstring/check_bstring.c
+++ b/test/bstring/check_bstring.c
@@ -96,6 +96,60 @@ START_TEST(test_compare)
 }
 END_TEST
 
+START_TEST(test_strcmp)
+{
+    ck_assert(str2cmp("an", 'a', 'n'));
+    ck_assert(str3cmp("old", 'o', 'l', 'd'));
+    ck_assert(str4cmp("farm", 'f', 'a', 'r', 'm'));
+    ck_assert(str5cmp("EIEIO", 'E', 'I', 'E', 'I', 'O'));
+    ck_assert(str6cmp("horses", 'h', 'o', 'r', 's', 'e', 's'));
+    ck_assert(str7cmp("beavers", 'b', 'e', 'a', 'v', 'e', 'r', 's'));
+    ck_assert(str8cmp("McDonald", 'M', 'c', 'D', 'o', 'n', 'a', 'l', 'd'));
+    ck_assert(str9cmp("elephants", 'e', 'l', 'e', 'p', 'h', 'a', 'n', 't',
+                's'));
+    ck_assert(str10cmp("everywhere", 'e', 'v', 'e', 'r', 'y', 'w', 'h', 'e',
+                'r', 'e'));
+    ck_assert(str11cmp("polar bears", 'p', 'o', 'l', 'a', 'r', ' ', 'b', 'e',
+                'a', 'r', 's'));
+    ck_assert(str12cmp("snow leopard", 's', 'n', 'o', 'w', ' ', 'l', 'e', 'o',
+                'p', 'a', 'r', 'd'));
+    ck_assert(!str12cmp("pocket mouse", 's', 'n', 'o', 'w', ' ', 'l', 'e', 'o',
+                'p', 'a', 'r', 'd'));
+}
+END_TEST
+
+
+START_TEST(test_atoi64)
+{
+    int64_t val;
+    struct bstring bstr;
+    char int64[CC_INT64_MAXLEN];
+
+    test_reset();
+
+    ck_assert_int_eq(bstring_atoi64(&val, &str2bstr("foo")), CC_ERROR);
+
+    ck_assert_int_eq(bstring_atoi64(&val, &str2bstr("123")), CC_OK);
+    ck_assert_uint_eq(val, 123);
+    ck_assert_int_eq(bstring_atoi64(&val, &str2bstr("-123")), CC_OK);
+    ck_assert_uint_eq(val, -123);
+
+    sprintf(int64, "%"PRIi64, INT64_MAX);
+    bstring_init(&bstr);
+    ck_assert_int_eq(bstring_copy(&bstr, int64, strlen(int64)), CC_OK);
+    ck_assert_int_eq(bstring_atoi64(&val, &bstr), CC_OK);
+    ck_assert_int_eq(val, INT64_MAX);
+    bstring_deinit(&bstr);
+
+    sprintf(int64, "%"PRIi64, INT64_MIN);
+    bstring_init(&bstr);
+    ck_assert_int_eq(bstring_copy(&bstr, int64, strlen(int64)), CC_OK);
+    ck_assert_int_eq(bstring_atoi64(&val, &bstr), CC_OK);
+    ck_assert_int_eq(val, INT64_MIN);
+    bstring_deinit(&bstr);
+}
+END_TEST
+
 START_TEST(test_atou64)
 {
     uint64_t val;
@@ -165,6 +219,8 @@ bstring_suite(void)
     tcase_add_test(tc_bstring, test_duplicate);
     tcase_add_test(tc_bstring, test_copy);
     tcase_add_test(tc_bstring, test_compare);
+    tcase_add_test(tc_bstring, test_strcmp);
+    tcase_add_test(tc_bstring, test_atoi64);
     tcase_add_test(tc_bstring, test_atou64);
     tcase_add_test(tc_bstring, test_bstring_alloc_and_free);
 
diff --git a/test/buffer/CMakeLists.txt b/test/buffer/CMakeLists.txt
new file mode 100644
index 000000000..aab20310c
--- /dev/null
+++ b/test/buffer/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(suite buf)
+set(test_name check_${suite})
+
+set(source check_${suite}.c)
+
+add_executable(${test_name} ${source})
+target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
+
+add_test(${test_name} ${test_name})
diff --git a/test/buffer/check_buf.c b/test/buffer/check_buf.c
new file mode 100644
index 000000000..65ad13c45
--- /dev/null
+++ b/test/buffer/check_buf.c
@@ -0,0 +1,429 @@
+#include <buffer/cc_buf.h>
+#include <buffer/cc_dbuf.h>
+
+#include <cc_bstring.h>
+
+#include <check.h>
+
+#define SUITE_NAME "buffer"
+#define DEBUG_LOG  SUITE_NAME ".log"
+
+#define TEST_BUF_CAP                                  32
+#define TEST_BUF_SIZE      (TEST_BUF_CAP + BUF_HDR_SIZE)
+#define TEST_BUF_POOLSIZE                              0
+#define TEST_DBUF_MAX                                  2
+
+static buf_metrics_st bmetrics;
+static dbuf_metrics_st dmetrics;
+
+static buf_options_st boptions;
+static dbuf_options_st doptions;
+
+/*
+ * utilities
+ */
+static void
+test_setup(void)
+{
+    bmetrics = (buf_metrics_st) { BUF_METRIC(METRIC_INIT) };
+    dmetrics = (dbuf_metrics_st) { DBUF_METRIC(METRIC_INIT) };
+
+    boptions  = (buf_options_st){
+        .buf_init_size = {
+            .set = true,
+            .type = OPTION_TYPE_UINT,
+            .val.vuint = TEST_BUF_SIZE,
+        },
+        .buf_poolsize = {
+            .set = true,
+            .type = OPTION_TYPE_UINT,
+            .val.vuint = TEST_BUF_POOLSIZE,
+        }};
+
+    doptions = (dbuf_options_st){
+        .dbuf_max_power = {
+            .set = true,
+            .type = OPTION_TYPE_UINT,
+            .val.vuint = TEST_DBUF_MAX,
+        }};
+
+    buf_setup(&boptions, &bmetrics);
+    dbuf_setup(&doptions, &dmetrics);
+}
+
+static void
+test_teardown(void)
+{
+    buf_teardown();
+    dbuf_teardown();
+}
+
+static void
+test_reset(void)
+{
+    test_teardown();
+    test_setup();
+}
+
+/*
+ * tests
+ */
+START_TEST(test_create_write_read_destroy_basic)
+{
+#define MSG "Hello World"
+#define NEW_CAP 100
+    struct buf *buf = NULL;
+    char message[sizeof(MSG)];
+
+    test_reset();
+    cc_memset(message, 0, sizeof(MSG));
+
+    /* Test create and metrics */
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+    ck_assert_int_eq(bmetrics.buf_curr.gauge, 1);
+    ck_assert_uint_eq(bmetrics.buf_create.counter, 1);
+    ck_assert_uint_eq(bmetrics.buf_destroy.counter, 0);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, TEST_BUF_SIZE);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_size(buf), TEST_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP - TEST_BUF_CAP);
+
+    /* Write message to buffer, and read, check buffer state */
+    ck_assert_uint_eq(buf_write(buf, MSG, sizeof(MSG)), sizeof(MSG));
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG));
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP - sizeof(MSG));
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP),
+            NEW_CAP - (TEST_BUF_CAP - sizeof(MSG)));
+
+    /* Read message from buffer, check buf state and if message is intact */
+    ck_assert_uint_eq(buf_read(message, buf, sizeof(MSG)), sizeof(MSG));
+    ck_assert_int_eq(cc_memcmp(message, MSG, sizeof(MSG)), 0);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP - sizeof(MSG));
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP),
+            NEW_CAP - (TEST_BUF_CAP - sizeof(MSG)));
+
+    /* Test destroy and metrics */
+    buf_destroy(&buf);
+    ck_assert_ptr_eq(buf, NULL);
+    ck_assert_int_eq(bmetrics.buf_curr.gauge, 0);
+    ck_assert_uint_eq(bmetrics.buf_create.counter, 1);
+    ck_assert_uint_eq(bmetrics.buf_destroy.counter, 1);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, 0);
+#undef MSG
+#undef CAP
+}
+END_TEST
+
+START_TEST(test_create_write_read_destroy_long)
+{
+#define MSG "this is a message that is long enough to fill up the entire buffer"
+#define NEW_CAP 100
+    struct buf *buf = NULL;
+    char message[sizeof(MSG)];
+
+    test_reset();
+    cc_memset(message, 0, sizeof(MSG));
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* Write message to buffer, expect full buffer */
+    ck_assert_uint_eq(buf_write(buf, MSG, sizeof(MSG)), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_rsize(buf), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_wsize(buf), 0);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP);
+
+    /* Read message from buffer, expect clipped message */
+    ck_assert_uint_eq(buf_read(message, buf, sizeof(MSG)), TEST_BUF_CAP);
+    ck_assert_int_eq(cc_memcmp(message, MSG, TEST_BUF_CAP), 0);
+    ck_assert_int_ne(cc_memcmp(message, MSG, TEST_BUF_CAP + 1), 0);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), 0);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP);
+
+    buf_destroy(&buf);
+#undef MSG
+#undef NEW_CAP
+}
+END_TEST
+
+START_TEST(test_lshift)
+{
+#define MSG "Hello World"
+#define NEW_CAP 100
+#define READ_LEN 5
+    struct buf *buf = NULL;
+    char message[sizeof(MSG)];
+
+    test_reset();
+    cc_memset(message, 0, sizeof(MSG));
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* Write message to buffer */
+    ck_assert_uint_eq(buf_write(buf, MSG, sizeof(MSG)), sizeof(MSG));
+
+    /* Read part of message */
+    ck_assert_uint_eq(buf_read(message, buf, READ_LEN), READ_LEN);
+    ck_assert_int_eq(cc_memcmp(message, MSG, READ_LEN), 0);
+    ck_assert_int_ne(cc_memcmp(message, MSG, READ_LEN + 1), 0);
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG) - READ_LEN);
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP - sizeof(MSG));
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP),
+            NEW_CAP - (TEST_BUF_CAP - sizeof(MSG)));
+
+    /* lshift buffer, check state */
+    buf_lshift(buf);
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG) - READ_LEN);
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP - (sizeof(MSG) - READ_LEN));
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP),
+            NEW_CAP - (TEST_BUF_CAP - (sizeof(MSG) - READ_LEN)));
+
+    /* Read rest of message */
+    ck_assert_uint_eq(buf_read(message + READ_LEN, buf, sizeof(MSG)),
+            sizeof(MSG) - READ_LEN);
+    ck_assert_int_eq(cc_memcmp(message, MSG, sizeof(MSG)), 0);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+
+    /* lshift again */
+    buf_lshift(buf);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_size(buf), TEST_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), TEST_BUF_CAP);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP - TEST_BUF_CAP);
+
+    buf_destroy(&buf);
+#undef MSG
+#undef NEW_CAP
+#undef READ_LEN
+}
+END_TEST
+
+START_TEST(test_rshift)
+{
+#define MSG "Hello World"
+#define NEW_CAP 100
+#define READ_LEN 5
+    struct buf *buf = NULL;
+    char message[sizeof(MSG)];
+
+    test_reset();
+    cc_memset(message, 0, sizeof(MSG));
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* Write message to buffer */
+    ck_assert_uint_eq(buf_write(buf, MSG, sizeof(MSG)), sizeof(MSG));
+
+    /* Read part of message */
+    ck_assert_uint_eq(buf_read(message, buf, READ_LEN), READ_LEN);
+
+    /* rshift buffer, check state */
+    buf_rshift(buf);
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG) - READ_LEN);
+    ck_assert_uint_eq(buf_wsize(buf), 0);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP);
+
+    /* Read rest of message */
+    ck_assert_uint_eq(buf_read(message + READ_LEN, buf, sizeof(MSG)),
+            sizeof(MSG) - READ_LEN);
+    ck_assert_int_eq(cc_memcmp(message, MSG, sizeof(MSG)), 0);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), 0);
+
+    buf_destroy(&buf);
+#undef MSG
+#undef NEW_CAP
+#undef READ_LEN
+}
+END_TEST
+
+START_TEST(test_dbuf_double_basic)
+{
+#define EXPECTED_BUF_SIZE                (TEST_BUF_SIZE * 2)
+#define EXPECTED_BUF_CAP  (EXPECTED_BUF_SIZE - BUF_HDR_SIZE)
+#define NEW_CAP                                          200
+    struct buf *buf;
+
+    test_reset();
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* double buffer, check state */
+    ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+    ck_assert_ptr_ne(buf, NULL);
+    ck_assert_int_eq(bmetrics.buf_curr.gauge, 1);
+    ck_assert_uint_eq(bmetrics.buf_create.counter, 1);
+    ck_assert_uint_eq(bmetrics.buf_destroy.counter, 0);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), EXPECTED_BUF_CAP);
+    ck_assert_uint_eq(buf_size(buf), EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), EXPECTED_BUF_CAP);
+    ck_assert_uint_eq(buf_new_cap(buf, NEW_CAP), NEW_CAP - EXPECTED_BUF_CAP);
+
+    /* destroy, check if memory gauge decremented correctly */
+    buf_destroy(&buf);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, 0);
+#undef EXPECTED_BUF_SIZE
+#undef EXPECTED_BUF_CAP
+#undef NEW_CAP
+}
+END_TEST
+
+START_TEST(test_dbuf_double_over_max)
+{
+    int i;
+    struct buf *buf;
+
+    test_reset();
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    for (i = 0; i < TEST_DBUF_MAX; ++i) {
+        ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+    }
+
+    ck_assert_int_eq(dbuf_double(&buf), CC_ERROR);
+
+    buf_destroy(&buf);
+}
+END_TEST
+
+START_TEST(test_dbuf_fit)
+{
+#define CAP_SMALL                         (TEST_BUF_CAP * 4)
+#define EXPECTED_BUF_SIZE                (TEST_BUF_SIZE * 4)
+#define EXPECTED_BUF_CAP  (EXPECTED_BUF_SIZE - BUF_HDR_SIZE)
+#define CAP_LARGE (TEST_BUF_CAP * 16)
+    struct buf *buf;
+
+    test_reset();
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* fit to small size, check state */
+    ck_assert_int_eq(dbuf_fit(&buf, CAP_SMALL), CC_OK);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_rsize(buf), 0);
+    ck_assert_uint_eq(buf_wsize(buf), EXPECTED_BUF_CAP);
+    ck_assert_uint_eq(buf_size(buf), EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), EXPECTED_BUF_CAP);
+
+    /* attempt to fit to large size */
+    ck_assert_int_eq(dbuf_fit(&buf, CAP_LARGE), CC_ERROR);
+
+    buf_destroy(&buf);
+#undef CAP_SMALL
+#undef EXPECTED_BUF_SIZE
+#undef EXPECTED_BUF_CAP
+#undef CAP_LARGE
+}
+END_TEST
+
+START_TEST(test_dbuf_shrink)
+{
+#define MSG1 "Hello World"
+#define MSG2 "this message can be contained by a singly doubled buffer"
+#define EXPECTED_BUF_SIZE                (TEST_BUF_SIZE * 2)
+#define EXPECTED_BUF_CAP  (EXPECTED_BUF_SIZE - BUF_HDR_SIZE)
+    struct buf *buf;
+
+    test_reset();
+
+    buf = buf_create();
+    ck_assert_ptr_ne(buf, NULL);
+
+    /* write first message, double twice, then shrink */
+    ck_assert_uint_eq(buf_write(buf, MSG1, sizeof(MSG1)), sizeof(MSG1));
+    ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+    ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+
+    /* shrink, then check state */
+    ck_assert_int_eq(dbuf_shrink(&buf), CC_OK);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, TEST_BUF_SIZE);
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG1));
+    ck_assert_uint_eq(buf_wsize(buf), TEST_BUF_CAP - sizeof(MSG1));
+    ck_assert_uint_eq(buf_size(buf), TEST_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), TEST_BUF_CAP);
+
+    buf_reset(buf);
+
+    /* double twice, then write second message */
+    ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+    ck_assert_int_eq(dbuf_double(&buf), CC_OK);
+    ck_assert_uint_eq(buf_write(buf, MSG2, sizeof(MSG2)), sizeof(MSG2));
+
+    /* shrink, then check state */
+    ck_assert_int_eq(dbuf_shrink(&buf), CC_OK);
+    ck_assert_int_eq(bmetrics.buf_memory.gauge, EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_rsize(buf), sizeof(MSG2));
+    ck_assert_uint_eq(buf_wsize(buf), EXPECTED_BUF_CAP - sizeof(MSG2));
+    ck_assert_uint_eq(buf_size(buf), EXPECTED_BUF_SIZE);
+    ck_assert_uint_eq(buf_capacity(buf), EXPECTED_BUF_CAP);
+
+    buf_destroy(&buf);
+#undef MSG1
+#undef MSG2
+#undef EXPECTED_BUF_SIZE
+#undef EXPECTED_BUF_CAP
+}
+END_TEST
+
+/*
+ * test suite
+ */
+static Suite *
+buf_suite(void)
+{
+    Suite *s = suite_create(SUITE_NAME);
+
+    TCase *tc_buf = tcase_create("buf test");
+    suite_add_tcase(s, tc_buf);
+
+    tcase_add_test(tc_buf, test_create_write_read_destroy_basic);
+    tcase_add_test(tc_buf, test_create_write_read_destroy_long);
+    tcase_add_test(tc_buf, test_lshift);
+    tcase_add_test(tc_buf, test_rshift);
+
+    TCase *tc_dbuf = tcase_create("dbuf test");
+    suite_add_tcase(s, tc_dbuf);
+
+    tcase_add_test(tc_dbuf, test_dbuf_double_basic);
+    tcase_add_test(tc_dbuf, test_dbuf_double_over_max);
+    tcase_add_test(tc_dbuf, test_dbuf_fit);
+    tcase_add_test(tc_dbuf, test_dbuf_shrink);
+
+    return s;
+}
+
+int
+main(void)
+{
+    int nfail;
+
+    /* setup */
+    test_setup();
+
+    Suite *suite = buf_suite();
+    SRunner *srunner = srunner_create(suite);
+    srunner_set_log(srunner, DEBUG_LOG);
+    srunner_run_all(srunner, CK_ENV); /* set CK_VEBOSITY in ENV to customize */
+    nfail = srunner_ntests_failed(srunner);
+    srunner_free(srunner);
+
+    /* teardown */
+    test_teardown();
+
+    return (nfail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/test/channel/pipe/CMakeLists.txt b/test/channel/pipe/CMakeLists.txt
index 35a8669cb..7a49bc7e7 100644
--- a/test/channel/pipe/CMakeLists.txt
+++ b/test/channel/pipe/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/channel/pipe/check_pipe.c b/test/channel/pipe/check_pipe.c
index e4e2fa672..5192119e2 100644
--- a/test/channel/pipe/check_pipe.c
+++ b/test/channel/pipe/check_pipe.c
@@ -7,6 +7,8 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <time.h>
+#include <errno.h>
 
 #define SUITE_NAME "pipe"
 #define DEBUG_LOG  SUITE_NAME ".log"
@@ -44,7 +46,20 @@ static void *do_write(void *_write_task)
 {
     struct write_task* task = _write_task;
     if (task->usleep) {
-        usleep(task->usleep);
+        struct timespec req;
+        struct timespec res;
+
+        req.tv_sec = task->usleep / 1000000;
+        req.tv_nsec = (task->usleep % 1000000) * 1000;
+
+        while (nanosleep(&req, &res) != 0) {
+            // If there is a different error then we should fail
+            // instead of potentially spinning indefinitely.
+            if (errno != EINTR)
+                break;
+
+            req = res;
+        }
     }
     ck_assert_int_eq(pipe_send(task->pipe, task->buf, task->nbytes), task->nbytes);
     return NULL;
@@ -89,7 +104,8 @@ START_TEST(test_read_blocking)
     pthread_t thread;
 #define READ_MESSAGE_LENGTH 12
 #define SLEEP_TIME 500000
-#define TOLERANCE_TIME 100000
+#define TOLERANCE_UNDER 10000
+#define TOLERANCE_OVER 100000
     char read_message[READ_MESSAGE_LENGTH];
     test_reset();
     duration_reset(&duration);
@@ -111,8 +127,8 @@ START_TEST(test_read_blocking)
     duration_stop(&duration);
     pthread_join(thread, NULL);
 
-    ck_assert_int_ge(duration_us(&duration), SLEEP_TIME);
-    ck_assert_int_le(duration_us(&duration), SLEEP_TIME + TOLERANCE_TIME);
+    ck_assert_int_ge(duration_us(&duration), SLEEP_TIME - TOLERANCE_UNDER);
+    ck_assert_int_le(duration_us(&duration), SLEEP_TIME + TOLERANCE_OVER);
 
     ck_assert_str_eq(write_message, read_message);
 
diff --git a/test/channel/tcp/CMakeLists.txt b/test/channel/tcp/CMakeLists.txt
index 7dfa9c54a..e661ae0a5 100644
--- a/test/channel/tcp/CMakeLists.txt
+++ b/test/channel/tcp/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/event/CMakeLists.txt b/test/event/CMakeLists.txt
index 027b7192b..e559afa8a 100644
--- a/test/event/CMakeLists.txt
+++ b/test/event/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/log/CMakeLists.txt b/test/log/CMakeLists.txt
index 5c87f50ee..3223e9c44 100644
--- a/test/log/CMakeLists.txt
+++ b/test/log/CMakeLists.txt
@@ -3,8 +3,20 @@ set(test_name check_${suite})
 
 set(source check_${suite}.c)
 
+set(CCOMMON_LIBS ccommon-static)
+
 add_executable(${test_name} ${source})
-target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
+target_link_libraries(
+    ${test_name}
+    ${CHECK_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${CCOMMON_LIBS}
+    m)
+
+if(OS_PLATFORM STREQUAL "OS_DARWIN")
+    # the "rand" crate links to the platform secure rng API, so it requires this
+    target_link_libraries(${test_name} "-framework Security")
+    set_target_properties(${test_name} PROPERTIES LINK_FLAGS "-Wl,-F/System/Library/Frameworks")
+endif()
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/log/check_log.c b/test/log/check_log.c
index 3139c60d7..365ae253c 100644
--- a/test/log/check_log.c
+++ b/test/log/check_log.c
@@ -4,6 +4,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <cc_mm.h>
 
 #define SUITE_NAME "log"
 #define DEBUG_LOG  SUITE_NAME ".log"
@@ -52,7 +53,6 @@ static void
 tmpname_destroy(char *path)
 {
     unlink(path);
-    path[strlen(path) - 2] = 0;
     rmdir(path);
     free(path);
 }
diff --git a/test/metric/CMakeLists.txt b/test/metric/CMakeLists.txt
index d693a8334..ec55a0180 100644
--- a/test/metric/CMakeLists.txt
+++ b/test/metric/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/option/CMakeLists.txt b/test/option/CMakeLists.txt
index 9dfe88081..d915013ae 100644
--- a/test/option/CMakeLists.txt
+++ b/test/option/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/pool/CMakeLists.txt b/test/pool/CMakeLists.txt
index c12118208..3db68955f 100644
--- a/test/pool/CMakeLists.txt
+++ b/test/pool/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/rbuf/CMakeLists.txt b/test/rbuf/CMakeLists.txt
index cfbfe661e..7f3176811 100644
--- a/test/rbuf/CMakeLists.txt
+++ b/test/rbuf/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/rbuf/check_rbuf.c b/test/rbuf/check_rbuf.c
index 3656747ea..e34925ec4 100644
--- a/test/rbuf/check_rbuf.c
+++ b/test/rbuf/check_rbuf.c
@@ -49,7 +49,6 @@ write_read_rbuf(struct rbuf *buffer, char *write_data, size_t w1_len, size_t w2_
     ck_assert_int_eq(rbuf_rcap(buffer), w1_len);
     ck_assert_int_eq(rbuf_wcap(buffer), w2_len);
 
-
     written = rbuf_write(buffer, &write_data[w1_len], w2_len);
     ck_assert_int_eq(written, w2_len);
 
diff --git a/test/ring_array/CMakeLists.txt b/test/ring_array/CMakeLists.txt
index 732100b67..c2f224801 100644
--- a/test/ring_array/CMakeLists.txt
+++ b/test/ring_array/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/ring_array/check_ring_array.c b/test/ring_array/check_ring_array.c
index c4bcc0845..a60a159a6 100644
--- a/test/ring_array/check_ring_array.c
+++ b/test/ring_array/check_ring_array.c
@@ -207,6 +207,7 @@ START_TEST(test_thread)
         }
     }
 
+    pthread_join(producer, NULL);
     ring_array_destroy(&arr);
 #undef ELEM_SIZE
 #undef CAP
diff --git a/test/time/timer/CMakeLists.txt b/test/time/timer/CMakeLists.txt
index 70e8e2a58..b7199dec7 100644
--- a/test/time/timer/CMakeLists.txt
+++ b/test/time/timer/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/time/wheel/CMakeLists.txt b/test/time/wheel/CMakeLists.txt
index a3c023a18..6bbffeb5d 100644
--- a/test/time/wheel/CMakeLists.txt
+++ b/test/time/wheel/CMakeLists.txt
@@ -6,5 +6,4 @@ set(source check_${suite}.c)
 add_executable(${test_name} ${source})
 target_link_libraries(${test_name} ccommon-static ${CHECK_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} m)
 
-add_dependencies(check ${test_name})
 add_test(${test_name} ${test_name})
diff --git a/test/time/wheel/check_wheel.c b/test/time/wheel/check_wheel.c
index 4bd4df0ee..177eb0008 100644
--- a/test/time/wheel/check_wheel.c
+++ b/test/time/wheel/check_wheel.c
@@ -116,13 +116,14 @@ END_TEST
 
 START_TEST(test_timing_wheel_recur)
 {
-#define TICK_NS 50000000
+#define TICK_NS 500000000
+#define SLEEP_NS 450000000
 #define NSLOT 3
 #define NTICK 2
 
     struct timeout tick, delay;
     struct timing_wheel *tw;
-    struct timespec ts = (struct timespec){0, TICK_NS};
+    struct timespec ts = (struct timespec){0, SLEEP_NS};
     int i = 0;
 
     test_reset();
@@ -134,21 +135,32 @@ START_TEST(test_timing_wheel_recur)
     timing_wheel_start(tw);
     ck_assert_int_le(timeout_ns(&tw->due), TICK_NS);
 
+    /* recurring events are inserted into the next tick at the earliest */
     timing_wheel_insert(tw, &delay, true, _incr_cb, &i);
 
-    /* tick unchanged */
+    /* tick not advanced yet, no event processed */
     timing_wheel_execute(tw);
     ck_assert_int_eq(tw->nprocess, 0);
     ck_assert_int_eq(tw->nevent, 1);
 
-    /* next 2 tick */
     nanosleep(&ts, NULL);
     nanosleep(&ts, NULL);
+    nanosleep(&ts, NULL);
+    /* elapsed time between 2 and 3 ticks.
+     * The first tick started empty; the next ticket has one
+     * event, and we should process it, and inserting it into
+     * the tick after that (because delay < tick, and re-insert
+     * will move the event by at least one slot).
+     * Despite the re-inserted event being due by wall clock
+     * since we process the tick at the end of that tick, we
+     * should only see one event processed.
+     */
     timing_wheel_execute(tw);
     ck_assert_int_eq(tw->nevent, 1);
     ck_assert_int_eq(tw->nprocess, 1);
     ck_assert_int_eq(i, 1);
     nanosleep(&ts, NULL);
+    /* elapsed time now between 3 and 4 ticks */
     timing_wheel_execute(tw);
     ck_assert_int_eq(tw->nevent, 1);
     ck_assert_int_eq(tw->nprocess, 2);
@@ -163,6 +175,7 @@ START_TEST(test_timing_wheel_recur)
 
 #undef NTICK
 #undef NSLOT
+#undef SLEEP_NS
 #undef TICK_NS
 }
 END_TEST