mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/shuffle_vector.h

@@ -1,287 +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_SHUFFLE_VECTOR_H
-#define MESH_SHUFFLE_VECTOR_H
-
-#include <iterator>
-#include <random>
-#include <utility>
-
-#include "rng/mwc.h"
-
-#include "internal.h"
-
-#include "mini_heap.h"
-
-using mesh::debug;
-
-namespace mesh {
-
-namespace sv {
-class Entry {
-public:
-  Entry() noexcept : _mhOffset{0}, _bitOffset{0} {
-  }
-
-  explicit Entry(uint8_t mhOff, uint8_t bitOff) : _mhOffset{mhOff}, _bitOffset{bitOff} {
-  }
-
-  Entry(const Entry &rhs) = default;
-
-  constexpr Entry(Entry &&rhs) = default;
-
-  Entry &operator=(const Entry &rhs) = default;
-
-  bool operator==(const Entry &rhs) const {
-    return _mhOffset == rhs._mhOffset && _bitOffset == rhs._bitOffset;
-  }
-
-  inline uint8_t ATTRIBUTE_ALWAYS_INLINE miniheapOffset() const {
-    return _mhOffset;
-  }
-
-  inline uint8_t ATTRIBUTE_ALWAYS_INLINE bit() const {
-    return _bitOffset;
-  }
-
-private:
-  uint8_t _mhOffset;
-  uint8_t _bitOffset;
-};
-static_assert(sizeof(Entry) == 2, "Entry too big!");
-}  // namespace sv
-
-class ShuffleVector {
-private:
-  DISALLOW_COPY_AND_ASSIGN(ShuffleVector);
-
-public:
-  ShuffleVector() : _prng(internal::seed(), internal::seed()) {
-    // set initialized = false;
-  }
-
-  ~ShuffleVector() {
-    d_assert(_attachedMiniheaps.size() == 0);
-  }
-
-  // post: list has the index of all bits set to 1 in it, in a random order
-  inline uint32_t ATTRIBUTE_ALWAYS_INLINE refillFrom(uint8_t mhOffset, internal::Bitmap &bitmap) {
-    d_assert(_maxCount > 0);
-    d_assert_msg(_maxCount <= kMaxShuffleVectorLength, "objCount? %zu <= %zu", _maxCount, kMaxShuffleVectorLength);
-
-    if (isFull()) {
-      return 0;
-    }
-
-    // d_assert(_maxCount == _attachedMiniheap->maxCount());
-
-    internal::RelaxedFixedBitmap newBitmap{static_cast<uint32_t>(_maxCount)};
-    newBitmap.setAll(_maxCount);
-
-    internal::RelaxedFixedBitmap localBits{static_cast<uint32_t>(_maxCount)};
-    bitmap.setAndExchangeAll(localBits.mut_bits(), newBitmap.bits());
-    localBits.invert();
-
-    uint32_t allocCount = 0;
-
-    const uint32_t maxCount = static_cast<uint32_t>(_maxCount);
-    for (auto const &i : localBits) {
-      // FIXME: this incredibly lurky conditional is because
-      // RelaxedFixedBitmap iterates over all 256 bits it has,
-      // regardless of the _maxCount set in the constructor -- we
-      // should fix that.
-      if (i >= maxCount) {
-        break;
-      }
-
-      if (unlikely(isFull())) {
-        // TODO: we don't have any more space in our shuffle vector
-        // for these bits we've pulled out of the MiniHeap's bitmap,
-        // so we need to set them as free again.  we should measure
-        // how often this happens, as its gonna be slow
-        refillFullSlowpath(bitmap, i);
-      } else {
-        _off--;
-        d_assert(_off >= 0);
-        d_assert(_off < _maxCount);
-        _list[_off] = sv::Entry{mhOffset, static_cast<uint8_t>(i)};
-        allocCount++;
-      }
-    }
-
-    return allocCount;
-  }
-
-  void ATTRIBUTE_NEVER_INLINE refillFullSlowpath(internal::Bitmap &bitmap, size_t i) {
-    bitmap.unset(i);
-  }
-
-  FixedArray<MiniHeap, kMaxMiniheapsPerShuffleVector> &miniheaps() {
-    return _attachedMiniheaps;
-  }
-
-  void refillMiniheaps() {
-    while (_off < _maxCount) {
-      const auto entry = pop();
-      _attachedMiniheaps[entry.miniheapOffset()]->freeOff(entry.bit());
-    }
-  }
-
-  inline bool isFull() const {
-    return _off <= 0;
-  }
-
-  inline bool isExhausted() const {
-    return _off >= _maxCount;
-  }
-
-  inline size_t maxCount() const {
-    return _maxCount;
-  }
-
-  inline bool ATTRIBUTE_ALWAYS_INLINE localRefill() {
-    uint32_t addedCapacity = 0;
-    const auto miniheapCount = _attachedMiniheaps.size();
-    for (uint32_t i = 0; i < miniheapCount && !isFull(); i++, _attachedOff++) {
-      if (_attachedOff >= miniheapCount) {
-        _attachedOff = 0;
-      }
-
-      auto mh = _attachedMiniheaps[_attachedOff];
-      if (mh->isFull()) {
-        continue;
-      }
-
-      const auto allocCount = refillFrom(_attachedOff, mh->writableBitmap());
-      addedCapacity |= allocCount;
-    }
-
-    if (addedCapacity > 0) {
-      if (kEnableShuffleOnInit) {
-        internal::mwcShuffle(&_list[_off], &_list[_maxCount], _prng);
-      }
-      return true;
-    }
-
-    return false;
-  }
-
-  // number of items in the list
-  inline uint32_t ATTRIBUTE_ALWAYS_INLINE length() const {
-    return _maxCount - _off;
-  }
-
-  // Pushing an element onto the freelist does a round of the
-  // Fisher-Yates shuffle if randomization level is >= 2.
-  inline void ATTRIBUTE_ALWAYS_INLINE push(sv::Entry entry) {
-    d_assert(_off > 0);  // we must have at least 1 free space in the list
-
-    _off--;
-    _list[_off] = entry;
-
-    if (kEnableShuffleOnFree) {
-      size_t swapOff = _prng.inRange(_off, maxCount() - 1);
-      std::swap(_list[_off], _list[swapOff]);
-    }
-  }
-
-  inline sv::Entry ATTRIBUTE_ALWAYS_INLINE pop() {
-    d_assert(_off >= 0);
-    d_assert(_off < _maxCount);
-
-    auto val = _list[_off];
-    _off++;
-
-    return val;
-  }
-
-  inline void ATTRIBUTE_ALWAYS_INLINE free(MiniHeap *mh, void *ptr) {
-    // const auto ptrval = reinterpret_cast<uintptr_t>(ptr);
-    // const size_t off = (ptrval - _start) / _objectSize;
-    // const size_t off = (ptrval - _start) * _objectSizeReciprocal;
-    const size_t off = mh->getUnmeshedOff(reinterpret_cast<const void *>(_arenaBegin), ptr);
-    // hard_assert_msg(off == off2, "%zu != %zu", off, off2);
-
-    d_assert(off < 256);
-
-    if (likely(_off > 0)) {
-      push(sv::Entry{mh->svOffset(), static_cast<uint8_t>(off)});
-    } else {
-      freeFullSlowpath(mh, off);
-    }
-  }
-
-  void ATTRIBUTE_NEVER_INLINE freeFullSlowpath(MiniHeap *mh, size_t off) {
-    mh->freeOff(off);
-  }
-
-  // an attach takes ownership of the reference to mh
-  inline void reinit() {
-    _off = _maxCount;
-    _attachedOff = 0;
-
-    internal::mwcShuffle(_attachedMiniheaps.array_begin(), _attachedMiniheaps.array_end(), _prng);
-
-    for (size_t i = 0; i < _attachedMiniheaps.size(); i++) {
-      const auto mh = _attachedMiniheaps[i];
-      _start[i] = mh->getSpanStart(_arenaBegin);
-      mh->setSvOffset(i);
-      d_assert(mh->isAttached());
-    }
-
-    const bool addedCapacity = localRefill();
-    d_assert(addedCapacity);
-  }
-
-  inline void *ATTRIBUTE_ALWAYS_INLINE ptrFromOffset(sv::Entry off) const {
-    d_assert(off.miniheapOffset() < _attachedMiniheaps.size());
-    return reinterpret_cast<void *>(_start[off.miniheapOffset()] + off.bit() * _objectSize);
-  }
-
-  inline void *ATTRIBUTE_ALWAYS_INLINE malloc() {
-    d_assert(!isExhausted());
-    const auto off = pop();
-    return ptrFromOffset(off);
-  }
-
-  inline size_t getSize() {
-    return _objectSize;
-  }
-
-  // called once, on initialization of ThreadLocalHeap
-  inline void initialInit(const char *arenaBegin, uint32_t sz) {
-    _arenaBegin = arenaBegin;
-    _objectSize = sz;
-    _objectSizeReciprocal = 1.0 / (float)sz;
-    _maxCount = max(kPageSize / sz, kMinStringLen);
-    // initially, we are unattached and therefor have no capacity.
-    // Setting _off to _maxCount causes isExhausted() to return true
-    // so that we don't separately have to check !isAttached() in the
-    // malloc fastpath.
-    _off = _maxCount;
-  }
-
-private:
-  uintptr_t _start[kMaxMiniheapsPerShuffleVector];                           // 32  32
-  const char *_arenaBegin;                                                   // 8   40
-  int16_t _maxCount{0};                                                      // 2   42
-  int16_t _off{0};                                                           // 2   44
-  uint32_t _objectSize{0};                                                   // 4   48
-  FixedArray<MiniHeap, kMaxMiniheapsPerShuffleVector> _attachedMiniheaps{};  // 36  128
-  MWC _prng;                                                                 // 36  84
-  float _objectSizeReciprocal{0.0};                                          // 4   88
-  uint32_t _attachedOff{0};                                                  //
-  sv::Entry _list[kMaxShuffleVectorLength] CACHELINE_ALIGNED;                // 512 640
-};
-
-static_assert(HL::gcd<sizeof(ShuffleVector), CACHELINE_SIZE>::value == CACHELINE_SIZE,
-              "ShuffleVector not multiple of cacheline size!");
-// FIXME should fit in 640
-// static_assert(sizeof(ShuffleVector) == 704, "ShuffleVector not expected size!");
-}  // namespace mesh
-
-#endif  // MESH_SHUFFLE_VECTOR_H

data/ext/mesh/mesh/src/size_classes.def

@@ -1,251 +0,0 @@
-// small size classes
-	1,	//     0 ->    16
-	1,	//     8 ->    16
-	1,	//    16 ->    16
-	2,	//    24 ->    32
-	2,	//    32 ->    32
-	3,	//    40 ->    48
-	3,	//    48 ->    48
-	4,	//    56 ->    64
-	4,	//    64 ->    64
-	5,	//    72 ->    80
-	5,	//    80 ->    80
-	6,	//    88 ->    96
-	6,	//    96 ->    96
-	7,	//   104 ->   112
-	7,	//   112 ->   112
-	8,	//   120 ->   128
-	8,	//   128 ->   128
-	9,	//   136 ->   160
-	9,	//   144 ->   160
-	9,	//   152 ->   160
-	9,	//   160 ->   160
-	10,	//   168 ->   192
-	10,	//   176 ->   192
-	10,	//   184 ->   192
-	10,	//   192 ->   192
-	11,	//   200 ->   224
-	11,	//   208 ->   224
-	11,	//   216 ->   224
-	11,	//   224 ->   224
-	12,	//   232 ->   256
-	12,	//   240 ->   256
-	12,	//   248 ->   256
-	12,	//   256 ->   256
-	13,	//   264 ->   320
-	13,	//   272 ->   320
-	13,	//   280 ->   320
-	13,	//   288 ->   320
-	13,	//   296 ->   320
-	13,	//   304 ->   320
-	13,	//   312 ->   320
-	13,	//   320 ->   320
-	14,	//   328 ->   384
-	14,	//   336 ->   384
-	14,	//   344 ->   384
-	14,	//   352 ->   384
-	14,	//   360 ->   384
-	14,	//   368 ->   384
-	14,	//   376 ->   384
-	14,	//   384 ->   384
-	15,	//   392 ->   448
-	15,	//   400 ->   448
-	15,	//   408 ->   448
-	15,	//   416 ->   448
-	15,	//   424 ->   448
-	15,	//   432 ->   448
-	15,	//   440 ->   448
-	15,	//   448 ->   448
-	16,	//   456 ->   512
-	16,	//   464 ->   512
-	16,	//   472 ->   512
-	16,	//   480 ->   512
-	16,	//   488 ->   512
-	16,	//   496 ->   512
-	16,	//   504 ->   512
-	16,	//   512 ->   512
-	17,	//   520 ->   640
-	17,	//   528 ->   640
-	17,	//   536 ->   640
-	17,	//   544 ->   640
-	17,	//   552 ->   640
-	17,	//   560 ->   640
-	17,	//   568 ->   640
-	17,	//   576 ->   640
-	17,	//   584 ->   640
-	17,	//   592 ->   640
-	17,	//   600 ->   640
-	17,	//   608 ->   640
-	17,	//   616 ->   640
-	17,	//   624 ->   640
-	17,	//   632 ->   640
-	17,	//   640 ->   640
-	18,	//   648 ->   768
-	18,	//   656 ->   768
-	18,	//   664 ->   768
-	18,	//   672 ->   768
-	18,	//   680 ->   768
-	18,	//   688 ->   768
-	18,	//   696 ->   768
-	18,	//   704 ->   768
-	18,	//   712 ->   768
-	18,	//   720 ->   768
-	18,	//   728 ->   768
-	18,	//   736 ->   768
-	18,	//   744 ->   768
-	18,	//   752 ->   768
-	18,	//   760 ->   768
-	18,	//   768 ->   768
-	19,	//   776 ->   896
-	19,	//   784 ->   896
-	19,	//   792 ->   896
-	19,	//   800 ->   896
-	19,	//   808 ->   896
-	19,	//   816 ->   896
-	19,	//   824 ->   896
-	19,	//   832 ->   896
-	19,	//   840 ->   896
-	19,	//   848 ->   896
-	19,	//   856 ->   896
-	19,	//   864 ->   896
-	19,	//   872 ->   896
-	19,	//   880 ->   896
-	19,	//   888 ->   896
-	19,	//   896 ->   896
-	20,	//   904 ->  1024
-	20,	//   912 ->  1024
-	20,	//   920 ->  1024
-	20,	//   928 ->  1024
-	20,	//   936 ->  1024
-	20,	//   944 ->  1024
-	20,	//   952 ->  1024
-	20,	//   960 ->  1024
-	20,	//   968 ->  1024
-	20,	//   976 ->  1024
-	20,	//   984 ->  1024
-	20,	//   992 ->  1024
-	20,	//  1000 ->  1024
-	20,	//  1008 ->  1024
-	20,	//  1016 ->  1024
-	20,	//  1024 ->  1024
-// large size classes
-	21,	//  1152 ->  2048
-	21,	//  1280 ->  2048
-	21,	//  1408 ->  2048
-	21,	//  1536 ->  2048
-	21,	//  1664 ->  2048
-	21,	//  1792 ->  2048
-	21,	//  1920 ->  2048
-	21,	//  2048 ->  2048
-	22,	//  2176 ->  4096
-	22,	//  2304 ->  4096
-	22,	//  2432 ->  4096
-	22,	//  2560 ->  4096
-	22,	//  2688 ->  4096
-	22,	//  2816 ->  4096
-	22,	//  2944 ->  4096
-	22,	//  3072 ->  4096
-	22,	//  3200 ->  4096
-	22,	//  3328 ->  4096
-	22,	//  3456 ->  4096
-	22,	//  3584 ->  4096
-	22,	//  3712 ->  4096
-	22,	//  3840 ->  4096
-	22,	//  3968 ->  4096
-	22,	//  4096 ->  4096
-	23,	//  4224 ->  8192
-	23,	//  4352 ->  8192
-	23,	//  4480 ->  8192
-	23,	//  4608 ->  8192
-	23,	//  4736 ->  8192
-	23,	//  4864 ->  8192
-	23,	//  4992 ->  8192
-	23,	//  5120 ->  8192
-	23,	//  5248 ->  8192
-	23,	//  5376 ->  8192
-	23,	//  5504 ->  8192
-	23,	//  5632 ->  8192
-	23,	//  5760 ->  8192
-	23,	//  5888 ->  8192
-	23,	//  6016 ->  8192
-	23,	//  6144 ->  8192
-	23,	//  6272 ->  8192
-	23,	//  6400 ->  8192
-	23,	//  6528 ->  8192
-	23,	//  6656 ->  8192
-	23,	//  6784 ->  8192
-	23,	//  6912 ->  8192
-	23,	//  7040 ->  8192
-	23,	//  7168 ->  8192
-	23,	//  7296 ->  8192
-	23,	//  7424 ->  8192
-	23,	//  7552 ->  8192
-	23,	//  7680 ->  8192
-	23,	//  7808 ->  8192
-	23,	//  7936 ->  8192
-	23,	//  8064 ->  8192
-	23,	//  8192 ->  8192
-	24,	//  8320 -> 16384
-	24,	//  8448 -> 16384
-	24,	//  8576 -> 16384
-	24,	//  8704 -> 16384
-	24,	//  8832 -> 16384
-	24,	//  8960 -> 16384
-	24,	//  9088 -> 16384
-	24,	//  9216 -> 16384
-	24,	//  9344 -> 16384
-	24,	//  9472 -> 16384
-	24,	//  9600 -> 16384
-	24,	//  9728 -> 16384
-	24,	//  9856 -> 16384
-	24,	//  9984 -> 16384
-	24,	// 10112 -> 16384
-	24,	// 10240 -> 16384
-	24,	// 10368 -> 16384
-	24,	// 10496 -> 16384
-	24,	// 10624 -> 16384
-	24,	// 10752 -> 16384
-	24,	// 10880 -> 16384
-	24,	// 11008 -> 16384
-	24,	// 11136 -> 16384
-	24,	// 11264 -> 16384
-	24,	// 11392 -> 16384
-	24,	// 11520 -> 16384
-	24,	// 11648 -> 16384
-	24,	// 11776 -> 16384
-	24,	// 11904 -> 16384
-	24,	// 12032 -> 16384
-	24,	// 12160 -> 16384
-	24,	// 12288 -> 16384
-	24,	// 12416 -> 16384
-	24,	// 12544 -> 16384
-	24,	// 12672 -> 16384
-	24,	// 12800 -> 16384
-	24,	// 12928 -> 16384
-	24,	// 13056 -> 16384
-	24,	// 13184 -> 16384
-	24,	// 13312 -> 16384
-	24,	// 13440 -> 16384
-	24,	// 13568 -> 16384
-	24,	// 13696 -> 16384
-	24,	// 13824 -> 16384
-	24,	// 13952 -> 16384
-	24,	// 14080 -> 16384
-	24,	// 14208 -> 16384
-	24,	// 14336 -> 16384
-	24,	// 14464 -> 16384
-	24,	// 14592 -> 16384
-	24,	// 14720 -> 16384
-	24,	// 14848 -> 16384
-	24,	// 14976 -> 16384
-	24,	// 15104 -> 16384
-	24,	// 15232 -> 16384
-	24,	// 15360 -> 16384
-	24,	// 15488 -> 16384
-	24,	// 15616 -> 16384
-	24,	// 15744 -> 16384
-	24,	// 15872 -> 16384
-	24,	// 16000 -> 16384
-	24,	// 16128 -> 16384
-	24,	// 16256 -> 16384
-	24,	// 16384 -> 16384