mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/gnu_wrapper.cc

@@ -1,75 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2019 The Heap-Layers and 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.
-
-#ifndef __GNUC__
-#error "This file requires the GNU compiler."
-#endif
-
-#include <errno.h>
-#include <malloc.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <new>
-
-/*
-  To use this library,
-  you only need to define the following allocation functions:
-
-  - xxmalloc
-  - xxfree
-  - xxmalloc_usable_size
-  - xxmalloc_lock
-  - xxmalloc_unlock
-
-  See the extern "C" block below for function prototypes and more
-  details. YOU SHOULD NOT NEED TO MODIFY ANY OF THE CODE HERE TO
-  SUPPORT ANY ALLOCATOR.
-
-
-  LIMITATIONS:
-
-  - This wrapper assumes that the underlying allocator will do "the
-    right thing" when xxfree() is called with a pointer internal to an
-    allocated object. Header-based allocators, for example, need not
-    apply.
-
-*/
-
-#define WEAK(x) __attribute__((weak, alias(#x)))
-#ifndef __THROW
-#define __THROW
-#endif
-
-#ifndef CACHELINE_ALIGNED_FN
-#define ATTRIBUTE_ALIGNED(s) __attribute__((aligned(s)))
-#define CACHELINE_SIZE 64
-#define CACHELINE_ALIGNED_FN ATTRIBUTE_ALIGNED(CACHELINE_SIZE)
-#endif
-
-#define CUSTOM_PREFIX(x) mesh_##x
-
-#define WEAK_REDEF1(type, fname, arg1) MESH_EXPORT type fname(arg1) __THROW WEAK(mesh_##fname)
-#define WEAK_REDEF2(type, fname, arg1, arg2) MESH_EXPORT type fname(arg1, arg2) __THROW WEAK(mesh_##fname)
-#define WEAK_REDEF3(type, fname, arg1, arg2, arg3) MESH_EXPORT type fname(arg1, arg2, arg3) __THROW WEAK(mesh_##fname)
-
-extern "C" {
-WEAK_REDEF1(void *, malloc, size_t);
-WEAK_REDEF1(void, free, void *);
-WEAK_REDEF1(void, cfree, void *);
-WEAK_REDEF2(void *, calloc, size_t, size_t);
-WEAK_REDEF2(void *, realloc, void *, size_t);
-WEAK_REDEF2(void *, memalign, size_t, size_t);
-WEAK_REDEF3(int, posix_memalign, void **, size_t, size_t);
-WEAK_REDEF2(void *, aligned_alloc, size_t, size_t);
-WEAK_REDEF1(size_t, malloc_usable_size, void *);
-}
-
-#include "wrapper.cc"
-#ifdef __GLIBC__
-// don't do this under musl
-#include "wrappers/gnuwrapper-hooks.cpp"
-#endif

data/ext/mesh/mesh/src/internal.h

@@ -1,356 +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_INTERNAL_H
-#define MESH_INTERNAL_H
-
-#ifdef __linux__
-#include <sys/syscall.h>
-#include <unistd.h>
-#endif
-
-#include <atomic>
-#include <unordered_set>
-
-#include <signal.h>
-#include <stdint.h>
-
-#include "common.h"
-#include "rng/mwc.h"
-
-// never allocate executable heap
-#define HL_MMAP_PROTECTION_MASK (PROT_READ | PROT_WRITE)
-#define MALLOC_TRACE 0
-
-#include "heaplayers.h"
-
-#include "partitioned_heap.h"
-
-#ifdef __linux__
-inline pid_t gettid(void) {
-  return syscall(__NR_gettid);
-}
-#endif
-#ifdef __APPLE__
-inline pid_t gettid(void) {
-  uint64_t tid;
-  pthread_threadid_np(NULL, &tid);
-  return static_cast<uint32_t>(tid);
-}
-#endif
-
-namespace mesh {
-
-namespace internal {
-enum PageType {
-  Clean = 0,
-  Dirty = 1,
-  Meshed = 2,
-  Unknown = 3,
-};
-}  // namespace internal
-
-class MiniHeapID {
-public:
-  MiniHeapID() noexcept : _id{0} {
-  }
-
-  explicit constexpr MiniHeapID(uint32_t id) : _id{id} {
-  }
-
-  MiniHeapID(const MiniHeapID &rhs) = default;
-
-  constexpr MiniHeapID(MiniHeapID &&rhs) = default;
-
-  MiniHeapID &operator=(const MiniHeapID &rhs) = default;
-
-  bool operator!=(const MiniHeapID &rhs) const {
-    return _id != rhs._id;
-  }
-
-  bool operator==(const MiniHeapID &rhs) const {
-    return _id == rhs._id;
-  }
-
-  bool hasValue() const {
-    return _id != 0;
-  }
-
-  uint32_t value() const {
-    return _id;
-  }
-
-private:
-  uint32_t _id;
-};
-
-namespace list {
-static constexpr MiniHeapID Head{UINT32_MAX};
-// TODO: add a type to represent this
-static constexpr uint8_t Full = 0;
-static constexpr uint8_t Partial = 1;
-static constexpr uint8_t Empty = 2;
-static constexpr uint8_t Attached = 3;
-static constexpr uint8_t Max = 4;
-}  // namespace list
-
-class MiniHeap;
-MiniHeap *GetMiniHeap(const MiniHeapID id);
-MiniHeapID GetMiniHeapID(const MiniHeap *mh);
-
-typedef std::array<MiniHeap *, kMaxSplitListSize> SplitArray;
-typedef std::array<std::pair<MiniHeap *, MiniHeap *>, kMaxMergeSets> MergeSetArray;
-
-template <typename Object, typename ID>
-class ListEntry {
-public:
-  typedef ListEntry<Object, ID> Entry;
-
-  ListEntry() noexcept : _prev{}, _next{} {
-  }
-
-  explicit constexpr ListEntry(ID prev, ID next) : _prev{prev}, _next{next} {
-  }
-
-  ListEntry(const ListEntry &rhs) = default;
-  ListEntry &operator=(const ListEntry &) = default;
-
-  inline bool empty() const {
-    return !_prev.hasValue() || !_next.hasValue();
-  }
-
-  inline ID next() const {
-    return _next;
-  }
-
-  inline ID prev() const {
-    return _prev;
-  }
-
-  inline void setNext(ID next) {
-    // mesh::debug("%p.setNext: %u\n", this, next);
-    _next = next;
-  }
-
-  inline void setPrev(ID prev) {
-    _prev = prev;
-  }
-
-  // add calls remove for you
-  void add(Entry *listHead, uint8_t listId, ID selfId, Object *newEntry) {
-    const uint8_t oldId = newEntry->freelistId();
-    d_assert(oldId != listId);
-    d_assert(!newEntry->isLargeAlloc());
-
-    Entry *newEntryFreelist = newEntry->getFreelist();
-    if (likely(newEntryFreelist->next().hasValue())) {
-      // we will be part of a list every time except the first time add is called after alloc
-      newEntryFreelist->remove(listHead);
-    }
-
-    newEntry->setFreelistId(listId);
-
-    const ID newEntryId = GetMiniHeapID(newEntry);
-    ID lastId = prev();
-    Entry *prevList = nullptr;
-    if (lastId == list::Head) {
-      prevList = this;
-    } else {
-      Object *last = GetMiniHeap(lastId);
-      prevList = last->getFreelist();
-    }
-    prevList->setNext(newEntryId);
-    *newEntry->getFreelist() = ListEntry{lastId, selfId};
-    this->setPrev(newEntryId);
-  }
-
-  void remove(Entry *listHead) {
-    ID prevId = _prev;
-    ID nextId = _next;
-    // we may have just been created + not added to any freelist yet
-    if (!prevId.hasValue() || !nextId.hasValue()) {
-      return;
-    }
-    Entry *prev = nullptr;
-    if (prevId == list::Head) {
-      prev = listHead;
-    } else {
-      Object *mh = GetMiniHeap(prevId);
-      d_assert(mh != nullptr);
-      prev = mh->getFreelist();
-    }
-    Entry *next = nullptr;
-    if (nextId == list::Head) {
-      next = listHead;
-    } else {
-      Object *mh = GetMiniHeap(nextId);
-      d_assert(mh != nullptr);
-      next = mh->getFreelist();
-    }
-
-    prev->setNext(nextId);
-    next->setPrev(prevId);
-    _prev = MiniHeapID{};
-    _next = MiniHeapID{};
-  }
-
-private:
-  MiniHeapID _prev{};
-  MiniHeapID _next{};
-};
-
-typedef ListEntry<MiniHeap, MiniHeapID> MiniHeapListEntry;
-
-typedef uint32_t Offset;
-typedef uint32_t Length;
-
-struct Span {
-  // offset and length are in pages
-  explicit Span(Offset _offset, Length _length) : offset(_offset), length(_length) {
-  }
-
-  Span(const Span &rhs) : offset(rhs.offset), length(rhs.length) {
-  }
-
-  Span &operator=(const Span &rhs) {
-    offset = rhs.offset;
-    length = rhs.length;
-    return *this;
-  }
-
-  Span(Span &&rhs) : offset(rhs.offset), length(rhs.length) {
-  }
-
-  bool empty() const {
-    return length == 0;
-  }
-
-  // reduce the size of this span to pageCount, return another span
-  // with the rest of the pages.
-  Span splitAfter(Length pageCount) {
-    d_assert(pageCount <= length);
-    auto restPageCount = length - pageCount;
-    length = pageCount;
-    return Span(offset + pageCount, restPageCount);
-  }
-
-  uint32_t spanClass() const {
-    return std::min(length, kSpanClassCount) - 1;
-  }
-
-  size_t byteLength() const {
-    return length * kPageSize;
-  }
-
-  inline bool operator==(const Span &rhs) {
-    return offset == rhs.offset && length == rhs.length;
-  }
-
-  inline bool operator!=(const Span &rhs) {
-    return !(*this == rhs);
-  }
-
-  Offset offset;
-  Length length;
-};
-
-// keep in-sync with the version in plasma/mesh.h
-enum BitType {
-  MESH_BIT_0,
-  MESH_BIT_1,
-  MESH_BIT_2,
-  MESH_BIT_3,
-  MESH_BIT_COUNT,
-};
-
-namespace internal {
-
-// return the kernel's perspective on our proportional set size
-size_t measurePssKiB();
-
-inline void *MaskToPage(const void *ptr) {
-  const auto ptrval = reinterpret_cast<uintptr_t>(ptr);
-  return reinterpret_cast<void *>(ptrval & (uintptr_t) ~(CPUInfo::PageSize - 1));
-}
-
-// efficiently copy data from srcFd to dstFd
-int copyFile(int dstFd, int srcFd, off_t off, size_t sz);
-
-// for mesh-internal data structures, like heap metadata
-class Heap : public ExactlyOneHeap<LockedHeap<PosixLockType, PartitionedHeap>> {
-private:
-  typedef ExactlyOneHeap<LockedHeap<PosixLockType, PartitionedHeap>> SuperHeap;
-
-public:
-  Heap() : SuperHeap() {
-    static_assert(Alignment % 16 == 0, "16-byte alignment");
-  }
-};
-
-// make a shared pointer allocated from our internal heap that will
-// also free to the internal heap when all references have been
-// dropped.
-template <typename T, class... Args>
-inline std::shared_ptr<T> make_shared(Args &&...args) {
-  // FIXME: somehow centralize this static.
-  static STLAllocator<T, Heap> heap;
-  return std::allocate_shared<T, STLAllocator<T, Heap>, Args...>(heap, std::forward<Args>(args)...);
-}
-
-extern STLAllocator<char, Heap> allocator;
-
-template <typename K, typename V>
-using unordered_map = std::unordered_map<K, V, hash<K>, equal_to<K>, STLAllocator<pair<const K, V>, Heap>>;
-
-template <typename K>
-using unordered_set = std::unordered_set<K, hash<K>, equal_to<K>, STLAllocator<K, Heap>>;
-
-template <typename K, typename V>
-using map = std::map<K, V, std::less<K>, STLAllocator<pair<const K, V>, Heap>>;
-
-typedef std::basic_string<char, std::char_traits<char>, STLAllocator<char, Heap>> string;
-
-template <typename T>
-using vector = std::vector<T, STLAllocator<T, Heap>>;
-
-// https://stackoverflow.com/questions/529831/returning-the-greatest-key-strictly-less-than-the-given-key-in-a-c-map
-template <typename Map>
-typename Map::const_iterator greatest_leq(Map const &m, typename Map::key_type const &k) {
-  typename Map::const_iterator it = m.upper_bound(k);
-  if (it != m.begin()) {
-    return --it;
-  }
-  return m.end();
-}
-
-// https://stackoverflow.com/questions/529831/returning-the-greatest-key-strictly-less-than-the-given-key-in-a-c-map
-template <typename Map>
-typename Map::iterator greatest_leq(Map &m, typename Map::key_type const &k) {
-  typename Map::iterator it = m.upper_bound(k);
-  if (it != m.begin()) {
-    return --it;
-  }
-  return m.end();
-}
-
-// based on LLVM's libcxx std::shuffle
-template <class _RandomAccessIterator, class _RNG>
-inline void mwcShuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _RNG &__rng) {
-  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-
-  difference_type __d = __last - __first;
-  if (__d > 1) {
-    for (--__last, --__d; __first < __last; ++__first, --__d) {
-      difference_type __i = __rng.inRange(0, __d);
-      if (__i != difference_type(0))
-        swap(*__first, *(__first + __i));
-    }
-  }
-}
-}  // namespace internal
-}  // namespace mesh
-
-#endif  // MESH_INTERNAL_H

data/ext/mesh/mesh/src/libmesh.cc

@@ -1,239 +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.
-
-#include <stdlib.h>
-
-#include "runtime.h"
-#include "thread_local_heap.h"
-
-using namespace mesh;
-
-static __attribute__((constructor)) void libmesh_init() {
-  mesh::real::init();
-
-  runtime().createSignalFd();
-  runtime().installSegfaultHandler();
-  runtime().initMaxMapCount();
-
-  char *meshPeriodStr = getenv("MESH_PERIOD_MS");
-  if (meshPeriodStr) {
-    long period = strtol(meshPeriodStr, nullptr, 10);
-    if (period < 0) {
-      period = 0;
-    }
-    runtime().setMeshPeriodMs(std::chrono::milliseconds{period});
-  }
-
-  char *bgThread = getenv("MESH_BACKGROUND_THREAD");
-  if (!bgThread)
-    return;
-
-  int shouldThread = atoi(bgThread);
-  if (shouldThread) {
-    runtime().startBgThread();
-  }
-}
-
-static __attribute__((destructor)) void libmesh_fini() {
-  char *mstats = getenv("MALLOCSTATS");
-  if (!mstats)
-    return;
-
-  int mlevel = atoi(mstats);
-  if (mlevel < 0)
-    mlevel = 0;
-  else if (mlevel > 2)
-    mlevel = 2;
-
-  runtime().heap().dumpStats(mlevel, false);
-}
-
-namespace mesh {
-ATTRIBUTE_NEVER_INLINE
-static void *allocSlowpath(size_t sz) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->malloc(sz);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static void *cxxNewSlowpath(size_t sz) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->cxxNew(sz);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static void freeSlowpath(void *ptr) {
-  // instead of instantiating a thread-local heap on free, just free
-  // to the global heap directly
-  runtime().heap().free(ptr);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static void *reallocSlowpath(void *oldPtr, size_t newSize) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->realloc(oldPtr, newSize);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static void *callocSlowpath(size_t count, size_t size) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->calloc(count, size);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static size_t usableSizeSlowpath(void *ptr) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->getSize(ptr);
-}
-
-ATTRIBUTE_NEVER_INLINE
-static void *memalignSlowpath(size_t alignment, size_t size) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeap();
-  return localHeap->memalign(alignment, size);
-}
-}  // namespace mesh
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void *mesh_malloc(size_t sz) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    return mesh::allocSlowpath(sz);
-  }
-
-  return localHeap->malloc(sz);
-}
-#define xxmalloc mesh_malloc
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void mesh_free(void *ptr) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    mesh::freeSlowpath(ptr);
-    return;
-  }
-
-  return localHeap->free(ptr);
-}
-#define xxfree mesh_free
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void mesh_sized_free(void *ptr, size_t sz) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    mesh::freeSlowpath(ptr);
-    return;
-  }
-
-  return localHeap->sizedFree(ptr, sz);
-}
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void *mesh_realloc(void *oldPtr, size_t newSize) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    return mesh::reallocSlowpath(oldPtr, newSize);
-  }
-
-  return localHeap->realloc(oldPtr, newSize);
-}
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN size_t mesh_malloc_usable_size(void *ptr) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    return mesh::usableSizeSlowpath(ptr);
-  }
-
-  return localHeap->getSize(ptr);
-}
-#define xxmalloc_usable_size mesh_malloc_usable_size
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void *mesh_memalign(size_t alignment, size_t size)
-#if !defined(__FreeBSD__) && !defined(__SVR4)
-    throw()
-#endif
-{
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    return mesh::memalignSlowpath(alignment, size);
-  }
-
-  return localHeap->memalign(alignment, size);
-}
-
-extern "C" MESH_EXPORT CACHELINE_ALIGNED_FN void *mesh_calloc(size_t count, size_t size) {
-  ThreadLocalHeap *localHeap = ThreadLocalHeap::GetHeapIfPresent();
-  if (unlikely(localHeap == nullptr)) {
-    return mesh::callocSlowpath(count, size);
-  }
-
-  return localHeap->calloc(count, size);
-}
-
-extern "C" {
-#ifdef __linux__
-size_t MESH_EXPORT mesh_usable_size(void *ptr) __attribute__((weak, alias("mesh_malloc_usable_size")));
-#else
-// aliases are not supported on darwin
-size_t MESH_EXPORT mesh_usable_size(void *ptr) {
-  return mesh_malloc_usable_size(ptr);
-}
-#endif  // __linux__
-
-// ensure we don't concurrently allocate/mess with internal heap data
-// structures while forking.  This is not normally invoked when
-// libmesh is dynamically linked or LD_PRELOADed into a binary.
-void MESH_EXPORT xxmalloc_lock(void) {
-  mesh::runtime().lock();
-}
-
-// ensure we don't concurrently allocate/mess with internal heap data
-// structures while forking.  This is not normally invoked when
-// libmesh is dynamically linked or LD_PRELOADed into a binary.
-void MESH_EXPORT xxmalloc_unlock(void) {
-  mesh::runtime().unlock();
-}
-
-int MESH_EXPORT sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) MESH_THROW {
-  return mesh::runtime().sigaction(signum, act, oldact);
-}
-
-int MESH_EXPORT sigprocmask(int how, const sigset_t *set, sigset_t *oldset) MESH_THROW {
-  return mesh::runtime().sigprocmask(how, set, oldset);
-}
-
-// we need to wrap pthread_create and pthread_exit so that we can
-// install our segfault handler and cleanup thread-local heaps.
-int MESH_EXPORT pthread_create(pthread_t *thread, const pthread_attr_t *attr, mesh::PthreadFn startRoutine,
-                               void *arg) MESH_THROW {
-  return mesh::runtime().createThread(thread, attr, startRoutine, arg);
-}
-
-void MESH_EXPORT ATTRIBUTE_NORETURN pthread_exit(void *retval) {
-  mesh::runtime().exitThread(retval);
-}
-
-// Same API as je_mallctl, allows a program to query stats and set
-// allocator-related options.
-int MESH_EXPORT mesh_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) {
-  return mesh::runtime().heap().mallctl(name, oldp, oldlenp, newp, newlen);
-}
-
-#ifdef __linux__
-
-int MESH_EXPORT epoll_wait(int __epfd, struct epoll_event *__events, int __maxevents, int __timeout) {
-  return mesh::runtime().epollWait(__epfd, __events, __maxevents, __timeout);
-}
-
-int MESH_EXPORT epoll_pwait(int __epfd, struct epoll_event *__events, int __maxevents, int __timeout,
-                            const __sigset_t *__ss) {
-  return mesh::runtime().epollPwait(__epfd, __events, __maxevents, __timeout, __ss);
-}
-
-#endif
-}
-
-#if defined(__linux__)
-#include "gnu_wrapper.cc"
-#elif defined(__APPLE__)
-#include "mac_wrapper.cc"
-#else
-#error "only linux and macOS support for now"
-#endif