mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/BUILD

@@ -1,222 +0,0 @@
-# Copyright 2020 The Mesh Authors. All rights reserved.
-# Use of this source code is governed by the Apache License,
-# Version 2.0, that can be found in the LICENSE file.
-
-load("//src:copts.bzl", "MESH_DEFAULT_COPTS")
-
-package(default_visibility = ["//visibility:private"])
-
-licenses(["notice"])  # Apache 2.0
-
-# used in copts.bzl to set llvm/gcc-only flags
-config_setting(
-    name = "llvm",
-    flag_values = {
-        "@bazel_tools//tools/cpp:compiler": "llvm",
-    },
-    visibility = ["//visibility:private"],
-)
-
-config_setting(
-    name = "disable_meshing",
-    values = {
-        "define": "disable_meshing=true",
-    },
-    visibility = ["//visibility:private"],
-)
-
-config_setting(
-    name = "disable_randomization",
-    values = {
-        "define": "disable_randomization=true",
-    },
-    visibility = ["//visibility:private"],
-)
-
-config_setting(
-    name = "shuffle_on_free",
-    values = {
-        "define": "shuffle_on_free=true",
-    },
-    visibility = ["//visibility:private"],
-)
-
-NO_BUILTIN_MALLOC = [
-    "-fno-builtin-malloc",
-    "-fno-builtin-free",
-]
-
-COMMON_DEFINES = [] + select({
-    ":disable_meshing": ["MESHING_ENABLED=0"],
-    "//conditions:default": ["MESHING_ENABLED=1"],
-}) + select({
-    ":disable_randomization": ["SHUFFLE_ON_INIT=0"],
-    "//conditions:default": ["SHUFFLE_ON_INIT=1"],
-}) + select({
-    ":shuffle_on_free": ["SHUFFLE_ON_FREE=1"],
-    "//conditions:default": ["SHUFFLE_ON_FREE=0"],
-}) + select({
-    "@bazel_tools//src/conditions:linux_x86_64": [
-        # "_FORTIFY_SOURCE=2",  # TODO: only in release; but I think Bazel takes care of this?
-        "_DEFAULT_SOURCE",
-        "_BSD_SOURCE",
-        "_XOPEN_SOURCE=700",
-    ],
-    "//conditions:default": [],
-})
-
-COMMON_LINKOPTS = [
-    "-lm",
-    "-lpthread",
-    "-ldl",
-] + select({
-    "@bazel_tools//src/conditions:linux_x86_64": [
-        "-Wl,--no-as-needed",
-        "-Wl,--no-add-needed",
-        "-Wl,--sort-common",
-        "-Wl,--hash-style=both",
-        "-Wl,--no-undefined",
-        "-Wl,-Bsymbolic-functions",
-        "-Wl,-z,now,-z,relro",
-        "-Wl,--exclude-libs=libc++.a",
-        "-Wl,--exclude-libs=libc++abi.a",
-        "-Wl,--exclude-libs=libunwind.a",
-    ],
-    "//conditions:default": [],
-})
-
-cc_library(
-    name = "mesh-core",
-    srcs = [
-        "d_assert.cc",
-        "global_heap.cc",
-        "measure_rss.cc",
-        "meshable_arena.cc",
-        "real.cc",
-        "runtime.cc",
-        "thread_local_heap.cc",
-    ],
-    hdrs = glob([
-        "*.h",
-        "plasma/*.h",
-        "rng/*.h",
-        "gnu_wrapper.cc",
-        "mac_wrapper.cc",
-        "rpl_printf.c",
-        "static/*.h",
-        "size_classes.def",
-    ]),
-    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
-    defines = COMMON_DEFINES,
-    linkopts = COMMON_LINKOPTS,
-    linkstatic = True,
-    visibility = ["//visibility:private"],
-    deps = [
-        "@org_heaplayers",
-    ],
-)
-
-cc_library(
-    name = "mesh-lib",
-    srcs = [
-        "libmesh.cc",
-    ],
-    hdrs = glob([
-        "*.h",
-        "plasma/*.h",
-        "rng/*.h",
-        "gnu_wrapper.cc",
-        "mac_wrapper.cc",
-        "static/*.h",
-        "size_classes.def",
-        "wrapper.cc",
-    ]),
-    # TODO: config options here too
-    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
-    defines = COMMON_DEFINES,
-    linkopts = COMMON_LINKOPTS,
-    linkstatic = True,
-    visibility = ["//visibility:private"],
-    deps = [
-        "@org_heaplayers",
-    ],
-)
-
-cc_library(
-    name = "mesh",
-    srcs = [
-        "d_assert.cc",
-        "global_heap.cc",
-        "libmesh.cc",
-        "measure_rss.cc",
-        "meshable_arena.cc",
-        "real.cc",
-        "runtime.cc",
-        "thread_local_heap.cc",
-    ],
-    hdrs = glob([
-        "*.h",
-        "plasma/*.h",
-        "rng/*.h",
-        "gnu_wrapper.cc",
-        "mac_wrapper.cc",
-        "wrapper.cc",
-        "rpl_printf.c",
-        "static/*.h",
-        "size_classes.def",
-    ]),
-    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
-    defines = COMMON_DEFINES,
-    linkopts = COMMON_LINKOPTS + select({
-        "@bazel_tools//src/conditions:darwin": [
-            "-install_name /usr/local/lib/libmesh.dylib",
-            "-compatibility_version 1",
-            "-current_version 1",
-            "-ldl",
-        ],
-        "//conditions:default": [],
-    }),
-    linkstatic = False,
-    visibility = ["//visibility:public"],
-    # disabled, as we directly specify the source files above.
-    # this is to work around a bazel bug on macOS where if we
-    # specify only deps, it produces an empty dylib
-    # deps = [
-    #     ":mesh-core",
-    #     ":mesh-lib",
-    # ],
-    deps = [
-        "@org_heaplayers",
-    ],
-    # only valid for cc_library
-    alwayslink = 1,
-)
-
-cc_test(
-    name = "unit-tests",
-    srcs = glob([
-        "testing/unit/*.cc",
-    ]),
-    copts = [
-        "-Isrc",
-    ] + MESH_DEFAULT_COPTS,
-    linkopts = COMMON_LINKOPTS,
-    deps = [
-        ":mesh-core",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "local-refill-benchmark",
-    srcs = ["testing/benchmark/local_refill.cc"],
-    copts = [
-        "-Isrc",
-    ] + NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
-    linkopts = COMMON_LINKOPTS,
-    deps = [
-        ":mesh-core",
-        "@com_google_benchmark//:benchmark",
-        "@com_google_googletest//:gtest_main",
-    ],
-)

data/ext/mesh/mesh/src/CMakeLists.txt

@@ -1,85 +0,0 @@
-#Include current folder to guarantee headers are found by files
-include_directories(./)
-include_directories(${CMAKE_CURRENT_BINARY_DIR}/../heap_layers-src)
-# include_directories(./vendor/Heap-Layers)
-
-#Create a common set of source files
-set(common_src
-        d_assert.cc
-        global_heap.cc
-        runtime.cc
-        real.cc
-        meshable_arena.cc
-        measure_rss.cc
-        thread_local_heap.cc
-        )
-
-#Create the set of source files for the mesh library
-set(mesh_src
-        ${common_src}
-        libmesh.cc
-        )
-#Add a target for the mesh shared library
-add_library(mesh SHARED ${mesh_src})
-target_link_libraries(mesh PRIVATE -pthread -ldl)
-
-#Create a set of source files for the unit tests
-set(unit_src
-        ${common_src}
-        ${google_src}
-        testing/unit/alignment.cc
-        testing/unit/bitmap_test.cc
-        testing/unit/concurrent_mesh_test.cc
-        testing/unit/mesh_test.cc
-        testing/unit/rng_test.cc
-        testing/unit/size_class_test.cc
-        testing/unit/triple_mesh_test.cc
-)
-#Add a target to the unit tests executable
-add_executable(unit.test ${unit_src})
-target_link_libraries(unit.test PRIVATE -ldl -pthread )
-
-set(GTEST_DIR ${CMAKE_CURRENT_BINARY_DIR}/../googletest-src/googletest)
-
-ExternalProject_Get_Property(googletest binary_dir)
-set(GTEST_LIBRARY_PATH ${binary_dir}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gtest.a)
-target_link_libraries(unit.test PRIVATE ${GTEST_LIBRARY_PATH})
-
-set(GTEST_MAIN_LIBRARY_PATH ${binary_dir}/lib/${CMAKE_FIND_LIBRARY_PREFIXES}gtest_main.a)
-target_link_libraries(unit.test PRIVATE ${GTEST_MAIN_LIBRARY_PATH})
-
-#Include header file paths to the unit tests
-target_include_directories(unit.test SYSTEM PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/../googletest-src/googletest/include)
-
-#Set specific compiler flags for the unit tests
-target_compile_definitions(unit.test PRIVATE -DGTEST_HAS_PTHREAD=1)
-target_compile_options(unit.test PRIVATE -Wno-unused-const-variable -Wno-unused-variable)
-
-#Deal with coverage
-if(${GCOV})
-    add_custom_target(coverage_gcc
-            COMMAND cd ${CMAKE_BINARY_DIR}/src/CMakeFiles/unit.test.dir/ && ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unit.test
-            COMMAND lcov -o app.info -c --directory ${CMAKE_BINARY_DIR}/src/CMakeFiles/unit.test.dir/
-            COMMAND genhtml app.info
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/coverage/
-            DEPENDS unit.test)
-endif()
-
-#todo
-if(${CLANGCOV})
-    add_custom_target(coverage_clang
-            COMMAND cd ${CMAKE_BINARY_DIR}/src/CMakeFiles/unit.test.dir/ && ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unit.test
-            COMMAND lcov -o app.info -c --directory ${CMAKE_BINARY_DIR}/src/CMakeFiles/unit.test.dir/
-            COMMAND genhtml app.info
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/coverage/
-            DEPENDS unit.test)
-    #add_custom_target(coverage_clang
-    #        COMMAND rm -f unit.test.profdata
-    #        COMMAND LLVM_PROFILE_FILE=default.profraw ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unit.test
-    #        COMMAND llvm-profdata merge -sparse default.profraw -o unit.test.profdata
-    #        COMMAND "llvm-cov show -format=html -instr-profile=unit.test.profdata ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unit.test -ignore-filename-regex=\\'.*(vendor|unit)/.*\\' >index.html"
-    #        COMMAND "llvm-cov report -instr-profile=unit.test.profdata ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unit.test -ignore-filename-regex='.*(vendor|unit)/.*' -use-color"
-    #        COMMAND rm -f default.profraw
-    #        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/coverage/
-    #        DEPENDS unit.test)
-endif()

data/ext/mesh/mesh/src/bitmap.h

@@ -1,590 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Mesh Authors. All rights reserved.
-// Use of this source code is governed by the Apache License,
-// Version 2.0, that can be found in the LICENSE file.
-
-#pragma once
-#ifndef MESH_BITMAP_H
-#define MESH_BITMAP_H
-
-#include <atomic>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-
-#include "common.h"
-#include "internal.h"
-
-#include "static/log.h"
-
-#include "heaplayers.h"
-
-namespace mesh {
-namespace bitmap {
-
-static constexpr size_t kWordBits = sizeof(size_t) * 8;
-static constexpr size_t kWordBytes = sizeof(size_t);
-/// The log of the number of bits in a size_t, for shifting.
-static constexpr size_t kWordBitshift = staticlog(kWordBits);
-// number of bytes used to store the bitmap -- rounds up to nearest sizeof(size_t)
-static inline constexpr size_t ATTRIBUTE_ALWAYS_INLINE representationSize(size_t bitCount) {
-  return kWordBits * ((bitCount + kWordBits - 1) / kWordBits) / 8;
-}
-static inline constexpr size_t ATTRIBUTE_ALWAYS_INLINE wordCount(size_t byteCount) {
-  return byteCount / kWordBytes;
-}
-/// To find the bit in a word, do this: word & getMask(bitPosition)
-/// @return a "mask" for the given position.
-static inline constexpr size_t ATTRIBUTE_ALWAYS_INLINE getMask(uint64_t pos) {
-  return 1UL << pos;
-}
-
-using std::atomic_compare_exchange_weak_explicit;
-using std::atomic_size_t;
-
-// enables iteration through the set bits of the bitmap
-template <typename Container>
-class BitmapIter : public std::iterator<std::forward_iterator_tag, size_t> {
-public:
-  BitmapIter(const Container &a, const size_t i) : _i(i), _cont(a) {
-  }
-  BitmapIter &operator++() {
-    if (unlikely(_i + 1 >= _cont.bitCount())) {
-      _i = _cont.bitCount();
-      return *this;
-    }
-
-    _i = _cont.lowestSetBitAt(_i + 1);
-    return *this;
-  }
-  bool operator==(const BitmapIter &rhs) const {
-    return _cont.bits() == rhs._cont.bits() && _i == rhs._i;
-  }
-  bool operator!=(const BitmapIter &rhs) const {
-    return _cont.bits() != rhs._cont.bits() || _i != rhs._i;
-  }
-  size_t &operator*() {
-    return _i;
-  }
-
-private:
-  size_t _i;
-  const Container &_cont;
-};
-
-template <size_t maxBits>
-class AtomicBitmapBase {
-private:
-  DISALLOW_COPY_AND_ASSIGN(AtomicBitmapBase);
-
-public:
-  typedef atomic_size_t word_t;
-
-  enum { MaxBitCount = maxBits };
-
-protected:
-  AtomicBitmapBase(size_t bitCount) {
-    d_assert_msg(bitCount <= maxBits, "max bits (%zu) exceeded: %zu", maxBits, bitCount);
-
-    static_assert(wordCount(representationSize(maxBits)) == 4, "unexpected representation size");
-    // for (size_t i = 0; i < wordCount(representationSize(maxBits)); i++) {
-    //   _bits[i].store(0, std::memory_order_relaxed);
-    // }
-    _bits[0].store(0, std::memory_order_relaxed);
-    _bits[1].store(0, std::memory_order_relaxed);
-    _bits[2].store(0, std::memory_order_relaxed);
-    _bits[3].store(0, std::memory_order_relaxed);
-    std::atomic_thread_fence(std::memory_order_release);
-  }
-
-  ~AtomicBitmapBase() {
-  }
-
-  inline void ATTRIBUTE_ALWAYS_INLINE setAndExchangeAll(size_t *oldBits, const size_t *newBits) {
-    // for (size_t i = 0; i < wordCount(representationSize(maxBits)); i++) {
-    //   oldBits[i] = _bits[i].exchange(newBits[i]);
-    // }
-    oldBits[0] = _bits[0].exchange(newBits[0], std::memory_order_acq_rel);
-    oldBits[1] = _bits[1].exchange(newBits[1], std::memory_order_acq_rel);
-    oldBits[2] = _bits[2].exchange(newBits[2], std::memory_order_acq_rel);
-    oldBits[3] = _bits[3].exchange(newBits[3], std::memory_order_acq_rel);
-  }
-
-public:
-  inline bool ATTRIBUTE_ALWAYS_INLINE setAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item].load(std::memory_order_relaxed);
-    while (!atomic_compare_exchange_weak_explicit(&_bits[item],               // address of word
-                                                  &oldValue,                  // old val
-                                                  oldValue | mask,            // new val
-                                                  std::memory_order_release,  // success mem model
-                                                  std::memory_order_relaxed)) {
-    }
-
-    return !(oldValue & mask);
-  }
-
-  inline bool ATTRIBUTE_ALWAYS_INLINE unsetAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item].load(std::memory_order_relaxed);
-    while (!atomic_compare_exchange_weak_explicit(&_bits[item],               // address of word
-                                                  &oldValue,                  // old val
-                                                  oldValue & ~mask,           // new val
-                                                  std::memory_order_release,  // success mem model
-                                                  std::memory_order_relaxed)) {
-    }
-
-    return !(oldValue & mask);
-  }
-
-  inline uint32_t ATTRIBUTE_ALWAYS_INLINE inUseCount() const {
-    return __builtin_popcountl(_bits[0]) + __builtin_popcountl(_bits[1]) + __builtin_popcountl(_bits[2]) +
-           __builtin_popcountl(_bits[3]);
-  }
-
-protected:
-  inline void nullBits() {
-  }
-
-  inline size_t ATTRIBUTE_ALWAYS_INLINE bitCount() const {
-    return maxBits;
-  }
-
-  word_t _bits[wordCount(representationSize(maxBits))] = {};
-};
-
-class RelaxedBitmapBase {
-private:
-  // we explicitly want this
-  // DISALLOW_COPY_AND_ASSIGN(RelaxedBitmapBase);
-
-public:
-  typedef size_t word_t;
-
-  enum { MaxBitCount = std::numeric_limits<uint64_t>::max() };
-
-protected:
-  RelaxedBitmapBase(size_t bitCount)
-      : _bitCount(bitCount),
-        _isDynamicallyAllocated(1),
-        _bits(reinterpret_cast<word_t *>(internal::Heap().malloc(representationSize(bitCount)))) {
-    d_assert(_bits != nullptr);
-    clear();
-  }
-
-  RelaxedBitmapBase(size_t bitCount, char *backingMemory, bool clear)
-      : _bitCount(bitCount), _isDynamicallyAllocated(0), _bits(reinterpret_cast<word_t *>(backingMemory)) {
-    d_assert(_bits != nullptr);
-    if (clear) {
-      this->clear();
-    }
-  }
-
-  ~RelaxedBitmapBase() {
-    if (_isDynamicallyAllocated && _bits) {
-      internal::Heap().free(_bits);
-    }
-    _bits = nullptr;
-  }
-
-public:
-  inline void invert() {
-    const size_t numWords = wordCount(representationSize(_bitCount));
-    for (size_t i = 0; i < numWords; i++) {
-      _bits[i] = ~_bits[i];
-    }
-  }
-
-  inline void setAll(uint64_t bitCount) {
-    for (size_t i = 0; bitCount > 0; i++) {
-      if (bitCount >= 64) {
-        _bits[i] = (unsigned long)-1;
-        bitCount -= 64;
-      } else {
-        _bits[i] = (1ULL << bitCount) - 1;
-        bitCount = 0;
-      }
-    }
-  }
-
-  inline bool setAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item];
-    _bits[item] = oldValue | mask;
-
-    return !(oldValue & mask);
-  }
-
-  /// Clears the bit at the given index.
-  inline bool unsetAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item];
-    _bits[item] = oldValue & ~mask;
-
-    return !(oldValue & mask);
-  }
-
-  inline uint32_t inUseCount() const {
-    const auto wordCount = representationSize(_bitCount) / sizeof(size_t);
-    uint32_t count = 0;
-    for (size_t i = 0; i < wordCount; i++) {
-      count += __builtin_popcountl(_bits[i]);
-    }
-    return count;
-  }
-
-protected:
-  inline void nullBits() {
-    _bits = nullptr;
-  }
-
-  void clear() {
-    memset(_bits, 0, representationSize(bitCount()));
-  }
-
-  inline size_t ATTRIBUTE_ALWAYS_INLINE bitCount() const {
-    return _bitCount;
-  }
-
-  const size_t _bitCount : 63;
-  const size_t _isDynamicallyAllocated : 1;
-  word_t *_bits;
-};
-
-template <size_t maxBits>
-class RelaxedFixedBitmapBase {
-private:
-  // we explicitly want to be able to copy these around
-  // DISALLOW_COPY_AND_ASSIGN(RelaxedFixedBitmapBase);
-
-public:
-  typedef size_t word_t;
-
-  enum { MaxBitCount = maxBits };
-
-protected:
-  RelaxedFixedBitmapBase(size_t bitCount) {
-    clear();
-  }
-
-public:
-  inline void ATTRIBUTE_ALWAYS_INLINE invert() {
-    // constexpr size_t numWords = wordCount(representationSize(maxBits));
-    // for (size_t i = 0; i < numWords; i++) {
-    //   _bits[i] = ~_bits[i];
-    // }
-    _bits[0] = ~_bits[0];
-    _bits[1] = ~_bits[1];
-    _bits[2] = ~_bits[2];
-    _bits[3] = ~_bits[3];
-  }
-
-  inline void ATTRIBUTE_ALWAYS_INLINE setAll(uint64_t bitCount) {
-    for (size_t i = 0; bitCount > 0; i++) {
-      if (bitCount >= 64) {
-        _bits[i] = (unsigned long)-1;
-        bitCount -= 64;
-      } else {
-        _bits[i] = (1ULL << bitCount) - 1;
-        bitCount = 0;
-      }
-    }
-  }
-
-  inline bool ATTRIBUTE_ALWAYS_INLINE setAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item];
-    _bits[item] = oldValue | mask;
-
-    return !(oldValue & mask);
-  }
-
-  /// Clears the bit at the given index.
-  inline bool ATTRIBUTE_ALWAYS_INLINE unsetAt(uint32_t item, uint32_t position) {
-    const auto mask = getMask(position);
-
-    size_t oldValue = _bits[item];
-    _bits[item] = oldValue & ~mask;
-
-    return !(oldValue & mask);
-  }
-
-  inline uint64_t ATTRIBUTE_ALWAYS_INLINE inUseCount() const {
-    constexpr auto wordCount = representationSize(maxBits) / sizeof(size_t);
-    uint32_t count = 0;
-    // for (size_t i = 0; i < wordCount; i++) {
-    //   count += __builtin_popcountl(_bits[i]);
-    // }
-    count += __builtin_popcountl(_bits[0]);
-    count += __builtin_popcountl(_bits[1]);
-    count += __builtin_popcountl(_bits[2]);
-    count += __builtin_popcountl(_bits[3]);
-    return count;
-  }
-
-protected:
-  inline void nullBits() {
-  }
-
-  void ATTRIBUTE_ALWAYS_INLINE clear() {
-    _bits[0] = 0;
-    _bits[1] = 0;
-    _bits[2] = 0;
-    _bits[3] = 0;
-  }
-
-  inline size_t ATTRIBUTE_ALWAYS_INLINE bitCount() const {
-    return maxBits;
-  }
-
-  word_t _bits[wordCount(representationSize(maxBits))] = {};
-};
-
-template <typename Super>
-class BitmapBase : public Super {
-public:
-  typedef typename Super::word_t word_t;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(BitmapBase);
-
-  // typedef AtomicBitmapBase Super;
-  // typedef RelaxedBitmapBase Super;
-  typedef BitmapBase<Super> Bitmap;
-
-  static_assert(sizeof(size_t) == sizeof(atomic_size_t), "no overhead atomics");
-  static_assert(sizeof(word_t) == sizeof(size_t), "word_t should be size_t");
-
-  BitmapBase() = delete;
-
-public:
-  typedef BitmapIter<Bitmap> iterator;
-  typedef BitmapIter<Bitmap> const const_iterator;
-
-  explicit BitmapBase(size_t bitCount) : Super(bitCount) {
-  }
-
-  explicit BitmapBase(size_t bitCount, char *backingMemory, bool clear = true) : Super(bitCount, backingMemory, clear) {
-  }
-
-  explicit BitmapBase(const std::string &str) : Super(str.length()) {
-    for (size_t i = 0; i < str.length(); ++i) {
-      char c = str[i];
-      d_assert_msg(c == '0' || c == '1', "expected 0 or 1 in bitstring, not %c ('%s')", c, str.c_str());
-      if (c == '1')
-        tryToSet(i);
-    }
-  }
-
-  explicit BitmapBase(const internal::string &str) : Super(str.length()) {
-    for (size_t i = 0; i < str.length(); ++i) {
-      char c = str[i];
-      d_assert_msg(c == '0' || c == '1', "expected 0 or 1 in bitstring, not %c ('%s')", c, str.c_str());
-      if (c == '1')
-        tryToSet(i);
-    }
-  }
-
-  BitmapBase(Bitmap &&rhs) : Super(rhs) {
-    rhs.Super::nullBits();
-  }
-
-  internal::string to_string(ssize_t bitCount = -1) const {
-    if (bitCount == -1)
-      bitCount = this->bitCount();
-    d_assert(0 <= bitCount && static_cast<size_t>(bitCount) <= this->bitCount());
-
-    internal::string s(bitCount + 1, 0);
-
-    for (ssize_t i = 0; i < bitCount; i++) {
-      s[i] = isSet(i) ? '1' : '0';
-    }
-
-    return s;
-  }
-
-  // number of bytes used to store the bitmap -- rounds up to nearest sizeof(size_t)
-  inline size_t byteCount() const {
-    return representationSize(bitCount());
-  }
-
-  inline size_t ATTRIBUTE_ALWAYS_INLINE bitCount() const {
-    return Super::bitCount();
-  }
-
-  inline uint64_t setFirstEmpty(uint64_t startingAt = 0) {
-    uint32_t startWord, off;
-    computeItemPosition(startingAt, startWord, off);
-
-    const size_t words = byteCount();
-    // const auto words = byteCount() / sizeof(size_t);
-    for (size_t i = startWord; i < words; i++) {
-      const size_t bits = Super::_bits[i];
-      if (bits == ~0UL) {
-        off = 0;
-        continue;
-      }
-
-      d_assert(off <= 63U);
-      size_t unsetBits = ~bits;
-      d_assert(unsetBits != 0);
-
-      // if the offset is 3, we want to mark the first 3 bits as 'set'
-      // or 'unavailable'.
-      unsetBits &= ~((1UL << off) - 1);
-
-      // if, after we've masked off everything below our offset there
-      // are no free bits, continue
-      if (unsetBits == 0) {
-        off = 0;
-        continue;
-      }
-
-      // debug("unset bits: %zx (off: %u, startingAt: %llu", unsetBits, off, startingAt);
-
-      size_t off = __builtin_ffsll(unsetBits) - 1;
-      const bool ok = Super::setAt(i, off);
-      // if we couldn't set the bit, we raced with a different thread.  try again.
-      if (!ok) {
-        off++;
-        continue;
-      }
-
-      return kWordBits * i + off;
-    }
-
-    debug("mesh: bitmap completely full, aborting.\n");
-    abort();
-  }
-
-  /// @return true iff the bit was not set (but it is now).
-  inline bool ATTRIBUTE_ALWAYS_INLINE tryToSet(uint64_t index) {
-    uint32_t item, position;
-    computeItemPosition(index, item, position);
-    return Super::setAt(item, position);
-  }
-
-  /// Clears the bit at the given index.
-  inline bool ATTRIBUTE_ALWAYS_INLINE unset(uint64_t index) {
-    uint32_t item, position;
-    computeItemPosition(index, item, position);
-
-    return Super::unsetAt(item, position);
-  }
-
-  // FIXME: who uses this? bad idea with atomics
-  inline bool ATTRIBUTE_ALWAYS_INLINE isSet(uint64_t index) const {
-    uint32_t item, position;
-    computeItemPosition(index, item, position);
-
-    return Super::_bits[item] & getMask(position);
-  }
-
-  const word_t *bits() const {
-    return Super::_bits;
-  }
-
-  word_t *mut_bits() {
-    return Super::_bits;
-  }
-
-  iterator begin() {
-    return iterator(*this, lowestSetBitAt(0));
-  }
-  iterator end() {
-    return iterator(*this, bitCount());
-  }
-  const_iterator begin() const {
-    return iterator(*this, lowestSetBitAt(0));
-  }
-  const_iterator end() const {
-    return iterator(*this, bitCount());
-  }
-  const_iterator cbegin() const {
-    return iterator(*this, lowestSetBitAt(0));
-  }
-  const_iterator cend() const {
-    return iterator(*this, bitCount());
-  }
-
-  size_t lowestSetBitAt(uint64_t startingAt) const {
-    uint32_t startWord, startOff;
-    computeItemPosition(startingAt, startWord, startOff);
-
-    const auto wordCount = byteCount() / sizeof(size_t);
-    for (size_t i = startWord; i < wordCount; i++) {
-      const auto mask = ~((1UL << startOff) - 1);
-      const auto bits = Super::_bits[i] & mask;
-      startOff = 0;
-
-      if (bits == 0ULL)
-        continue;
-
-      const size_t off = __builtin_ffsl(bits) - 1;
-
-      const auto bit = kWordBits * i + off;
-      return bit < bitCount() ? bit : bitCount();
-    }
-
-    return bitCount();
-  }
-
-  size_t highestSetBitBeforeOrAt(uint64_t startingAt) const {
-    uint32_t startWord, startOff;
-    computeItemPosition(startingAt, startWord, startOff);
-
-    const auto wordCount = byteCount() / sizeof(size_t);
-    for (ssize_t i = startWord; i >= 0; i--) {
-      uint64_t mask = (1UL << (startOff + 1)) - 1;
-      if (startOff == 63) {
-        mask = ~0UL;
-      }
-      const auto bits = Super::_bits[i] & mask;
-      const auto origStartOff = startOff;
-      startOff = 63;
-
-      if (bits == 0ULL)
-        continue;
-
-      const size_t off = 64 - __builtin_clzl(bits) - 1;
-
-      const auto bit = kWordBits * i + off;
-      return bit < bitCount() ? bit : bitCount();
-    }
-
-    return 0;
-  }
-
-  inline void setAndExchangeAll(size_t *oldBits, const size_t *newBits) {
-    Super::setAndExchangeAll(oldBits, newBits);
-  }
-
-private:
-  /// Given an index, compute its item (word) and position within the word.
-  inline void ATTRIBUTE_ALWAYS_INLINE computeItemPosition(uint64_t index, uint32_t &item, uint32_t &position) const {
-    d_assert(index < bitCount());
-    item = index >> kWordBitshift;
-    position = index & (kWordBits - 1);
-    d_assert(position == index - (item << kWordBitshift));
-    d_assert(item < byteCount() / 8);
-  }
-};
-}  // namespace bitmap
-
-namespace internal {
-typedef bitmap::BitmapBase<bitmap::AtomicBitmapBase<256>> Bitmap;
-typedef bitmap::BitmapBase<bitmap::RelaxedFixedBitmapBase<256>> RelaxedFixedBitmap;
-typedef bitmap::BitmapBase<bitmap::RelaxedBitmapBase> RelaxedBitmap;
-
-static_assert(sizeof(Bitmap) == sizeof(size_t) * 4, "Bitmap unexpected size");
-static_assert(sizeof(RelaxedFixedBitmap) == sizeof(size_t) * 4, "Bitmap unexpected size");
-static_assert(sizeof(RelaxedBitmap) == sizeof(size_t) * 2, "Bitmap unexpected size");
-}  // namespace internal
-}  // namespace mesh
-
-#endif  // MESH_BITMAP_H