mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/testing/thread.cc

@@ -1,35 +0,0 @@
-#include <iostream>
-#include <mutex>
-#include <thread>
-
-int g_i = 0;
-std::mutex g_i_mutex;  // protects g_i
-
-volatile __thread char *c;
-
-void safe_increment() {
-  std::lock_guard<std::mutex> lock(g_i_mutex);
-  ++g_i;
-
-  for (size_t i = 0; i < 100; ++i) {
-    c = new char[16];
-    delete c;
-  }
-
-  std::cout << std::this_thread::get_id() << ": " << g_i << '\n';
-
-  // g_i_mutex is automatically released when lock
-  // goes out of scope
-}
-
-int main() {
-  std::cout << __func__ << ": " << g_i << '\n';
-
-  std::thread t1(safe_increment);
-  std::thread t2(safe_increment);
-
-  t1.join();
-  t2.join();
-
-  std::cout << __func__ << ": " << g_i << '\n';
-}

data/ext/mesh/mesh/src/testing/unit/alignment.cc

@@ -1,56 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2017 University of Massachusetts, Amherst
-
-#include <stdalign.h>
-#include <cstdint>
-#include <cstdlib>
-
-#include "gtest/gtest.h"
-
-#include "common.h"
-#include "internal.h"
-#include "thread_local_heap.h"
-
-using namespace mesh;
-
-TEST(Alignment, NaturalAlignment) {
-  auto heap = ThreadLocalHeap::GetHeap();
-
-  void **ptrs = reinterpret_cast<void **>(calloc(256, sizeof(void *)));
-  for (size_t size = 0; size < 4096; size += 4) {
-    for (size_t alignment = 2; alignment <= 4096; alignment *= 2) {
-      // debug("size: %zu align: %zu\n", size, alignment);
-      bool logged = false;
-      for (size_t i = 0; i <= 256; i++) {
-        void *ptr = heap->memalign(alignment, size);
-        if (!logged) {
-          size_t actual = heap->getSize(ptr);
-          // debug("%10zu %10zu %10zu %10p\n", size, actual, alignment, ptr);
-          logged = true;
-        }
-        const auto ptrval = reinterpret_cast<uintptr_t>(ptr);
-        ASSERT_EQ(ptrval % alignment, 0UL);
-        ptrs[i] = ptr;
-      }
-      for (size_t i = 0; i <= 256; i++) {
-        heap->free(ptrs[i]);
-      }
-    }
-  }
-  heap->releaseAll();
-  mesh::runtime().heap().flushAllBins();
-  memset(ptrs, 0, 256 * sizeof(void *));
-  free(ptrs);
-}
-
-TEST(Alignment, NonOverlapping) {
-  auto heap = ThreadLocalHeap::GetHeap();
-
-  const uintptr_t a = reinterpret_cast<uintptr_t>(heap->malloc(-8));
-  const uintptr_t b = reinterpret_cast<uintptr_t>(heap->malloc(-8));
-
-  // we should return nullptr for crazy allocations like this.
-  // Fixes #62
-  ASSERT_EQ(a, NULL);
-  ASSERT_EQ(b, NULL);
-}

data/ext/mesh/mesh/src/testing/unit/bitmap_test.cc

@@ -1,274 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2017 University of Massachusetts, Amherst
-
-#include <cstdint>
-#include <cstdlib>
-#include <unordered_map>
-
-#include "gtest/gtest.h"
-
-#include "bitmap.h"
-
-#include "heaplayers.h"
-
-TEST(BitmapTest, RepresentationSize) {
-  ASSERT_EQ(0UL, mesh::bitmap::representationSize(0));
-  ASSERT_EQ(8UL, mesh::bitmap::representationSize(1));
-  ASSERT_EQ(8UL, mesh::bitmap::representationSize(64));
-  ASSERT_EQ(32UL, mesh::bitmap::representationSize(256));
-  ASSERT_EQ(4UL, mesh::bitmap::representationSize(256) / sizeof(size_t));
-}
-
-TEST(BitmapTest, LowestSetBitAt) {
-  mesh::internal::RelaxedBitmap bits{128};
-
-  bits.tryToSet(6);
-  ASSERT_EQ(6UL, bits.lowestSetBitAt(0));
-  ASSERT_EQ(6UL, bits.lowestSetBitAt(5));
-  ASSERT_EQ(6UL, bits.lowestSetBitAt(6));
-  ASSERT_EQ(128UL, bits.lowestSetBitAt(7));
-  bits.tryToSet(123);
-  ASSERT_EQ(123UL, bits.lowestSetBitAt(7));
-}
-
-TEST(BitmapTest, HighestSetBitAt) {
-  mesh::internal::RelaxedBitmap bits{128};
-
-  bits.tryToSet(6);
-  ASSERT_EQ(0UL, bits.highestSetBitBeforeOrAt(0));
-  ASSERT_EQ(0UL, bits.highestSetBitBeforeOrAt(5));
-  ASSERT_EQ(6UL, bits.highestSetBitBeforeOrAt(6));
-  ASSERT_EQ(6UL, bits.highestSetBitBeforeOrAt(7));
-  ASSERT_EQ(6UL, bits.highestSetBitBeforeOrAt(127));
-  bits.tryToSet(123);
-  ASSERT_EQ(123UL, bits.highestSetBitBeforeOrAt(127));
-}
-
-TEST(BitmapTest, SetAndExchangeAll) {
-  const auto maxCount = 128;
-
-  mesh::internal::Bitmap bitmap{maxCount};
-  bitmap.tryToSet(3);
-  bitmap.tryToSet(4);
-  bitmap.tryToSet(127);
-
-  mesh::internal::RelaxedFixedBitmap newBitmap{maxCount};
-  newBitmap.setAll(maxCount);
-
-  mesh::internal::RelaxedFixedBitmap localBits{maxCount};
-  bitmap.setAndExchangeAll(localBits.mut_bits(), newBitmap.bits());
-  localBits.invert();
-
-  for (auto const &i : localBits) {
-    if (i >= maxCount) {
-      break;
-    }
-    ASSERT_TRUE(bitmap.isSet(i));
-    ASSERT_TRUE(newBitmap.isSet(i));
-    switch (i) {
-    case 3:
-    case 4:
-    case 127:
-      ASSERT_FALSE(localBits.isSet(i));
-      break;
-    default:
-      ASSERT_TRUE(localBits.isSet(i));
-      break;
-    }
-  }
-}
-
-TEST(BitmapTest, SetAll) {
-  const auto maxCount = 88;
-
-  uint64_t bits1[4] = {0, 0, 0, 0};
-  mesh::internal::RelaxedBitmap bitmap1{maxCount, reinterpret_cast<char *>(bits1), false};
-  for (size_t i = 0; i < maxCount; i++) {
-    bitmap1.tryToSet(i);
-  }
-
-  uint64_t bits2[4] = {0, 0, 0, 0};
-  mesh::internal::RelaxedBitmap bitmap2{maxCount, reinterpret_cast<char *>(bits2), false};
-  bitmap2.setAll(maxCount);
-
-  for (size_t i = 0; i < maxCount; i++) {
-    ASSERT_TRUE(bitmap1.isSet(i));
-    ASSERT_TRUE(bitmap2.isSet(i));
-  }
-}
-
-TEST(BitmapTest, SetGet) {
-  const int NTRIALS = 1000;
-
-  for (int n = 2; n <= mesh::internal::Bitmap::MaxBitCount; n *= 2) {
-    mesh::internal::Bitmap b{static_cast<size_t>(n)};
-    int *rnd = reinterpret_cast<int *>(calloc(n, sizeof(int)));
-
-    for (int k = 0; k < NTRIALS; k++) {
-      // Generate a random stream of bits.
-      ASSERT_NE(rnd, nullptr);
-
-      for (int i = 0; i < n; i++) {
-        rnd[i] = lrand48() % 2;
-      }
-
-      for (int i = 0; i < n; i++) {
-        if (rnd[i] == 0) {
-          bool r = b.tryToSet(i);
-          ASSERT_TRUE(r);
-        } else {
-          ASSERT_FALSE(b.isSet(i));
-          b.unset(i);
-        }
-      }
-      for (int i = 0; i < n; i++) {
-        if (rnd[i] == 0) {
-          ASSERT_TRUE(b.isSet(i));
-          b.unset(i);
-        } else {
-          ASSERT_FALSE(b.isSet(i));
-        }
-      }
-    }
-    free(rnd);
-  }
-}
-
-TEST(BitmapTest, SetGetRelaxed) {
-  const int NTRIALS = 1000;
-
-  for (int n = 10; n < 10000; n *= 2) {
-    mesh::internal::RelaxedBitmap b{static_cast<size_t>(n)};
-    int *rnd = reinterpret_cast<int *>(calloc(n, sizeof(int)));
-
-    for (int k = 0; k < NTRIALS; k++) {
-      // Generate a random stream of bits.
-      ASSERT_NE(rnd, nullptr);
-
-      for (int i = 0; i < n; i++) {
-        rnd[i] = lrand48() % 2;
-      }
-
-      for (int i = 0; i < n; i++) {
-        if (rnd[i] == 0) {
-          bool r = b.tryToSet(i);
-          ASSERT_TRUE(r);
-        } else {
-          ASSERT_FALSE(b.isSet(i));
-          b.unset(i);
-        }
-      }
-      for (int i = 0; i < n; i++) {
-        if (rnd[i] == 0) {
-          ASSERT_TRUE(b.isSet(i));
-          b.unset(i);
-        } else {
-          ASSERT_FALSE(b.isSet(i));
-        }
-      }
-    }
-    free(rnd);
-  }
-}
-
-TEST(BitmapTest, Builtins) {
-  mesh::internal::Bitmap b{256};
-
-  uint64_t i = b.setFirstEmpty();
-  ASSERT_EQ(i, 0ULL);
-
-  b.unset(i);
-
-  static constexpr uint64_t curr = 66;
-  for (size_t i = 0; i < curr; i++) {
-    b.tryToSet(i);
-  }
-
-  i = b.setFirstEmpty();
-  ASSERT_EQ(i, curr);
-
-  for (size_t i = 0; i < curr; i++) {
-    b.unset(i);
-  }
-
-  i = b.setFirstEmpty();
-  ASSERT_EQ(i, 0ULL);
-
-  i = b.setFirstEmpty(4);
-  ASSERT_EQ(i, 4ULL);
-
-  i = b.setFirstEmpty(111);
-  ASSERT_EQ(i, 111ULL);
-}
-
-TEST(BitmapTest, Iter) {
-  mesh::internal::RelaxedBitmap b{512};
-
-  b.tryToSet(0);
-  b.tryToSet(200);
-  b.tryToSet(500);
-
-  std::unordered_map<size_t, bool> bits;
-
-  ASSERT_EQ(bits.size(), 0ULL);
-
-  size_t n = 0;
-  for (auto const &off : b) {
-    bits[off] = true;
-    n++;
-  }
-
-  ASSERT_EQ(n, 3ULL);
-  ASSERT_EQ(bits.size(), 3ULL);
-
-  ASSERT_EQ(bits[0], true);
-  ASSERT_EQ(bits[200], true);
-  ASSERT_EQ(bits[500], true);
-
-  ASSERT_EQ(bits[1], false);
-}
-
-TEST(BitmapTest, Iter2) {
-  mesh::internal::RelaxedBitmap b{512};
-
-  b.tryToSet(200);
-  b.tryToSet(500);
-
-  std::unordered_map<size_t, bool> bits;
-
-  ASSERT_EQ(bits.size(), 0ULL);
-
-  size_t n = 0;
-  for (auto const &off : b) {
-    bits[off] = true;
-    n++;
-  }
-
-  ASSERT_EQ(n, 2ULL);
-  ASSERT_EQ(bits.size(), 2ULL);
-
-  ASSERT_EQ(bits[200], true);
-  ASSERT_EQ(bits[500], true);
-
-  ASSERT_EQ(bits.find(0), bits.end());
-}
-
-TEST(BitmapTest, SetHalf) {
-  for (size_t i = 2; i <= 2048; i *= 2) {
-    const auto nBits = i;
-
-    mesh::internal::RelaxedBitmap bitmap{nBits};
-
-    ASSERT_TRUE(bitmap.byteCount() >= nBits / 8);
-
-    for (size_t i = 0; i < nBits / 2; i++) {
-      bitmap.tryToSet(i);
-      ASSERT_TRUE(bitmap.isSet(i));
-      ASSERT_TRUE(bitmap.inUseCount() == i + 1);
-    }
-
-    ASSERT_TRUE(bitmap.isSet(0));
-
-    ASSERT_TRUE(bitmap.inUseCount() == nBits / 2);
-  }
-}

data/ext/mesh/mesh/src/testing/unit/concurrent_mesh_test.cc

@@ -1,185 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// Copyright 2017 University of Massachusetts, Amherst
-
-#include <sched.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <atomic>
-#include <mutex>
-#include <thread>
-
-#include "gtest/gtest.h"
-
-#include "internal.h"
-#include "meshing.h"
-#include "runtime.h"
-#include "shuffle_vector.h"
-
-using namespace std;
-using namespace mesh;
-
-static constexpr uint32_t StrLen = 128;
-static constexpr uint32_t ObjCount = 32;
-
-static char *s1;
-static char *s2;
-
-static atomic<int> ShouldExit;
-static atomic<int> ShouldContinueTest;
-
-// we need to wrap pthread_create so that we can safely implement a
-// stop-the-world quiescent period for the copy/mremap phase of
-// meshing -- copied from libmesh.cc
-
-#ifdef __APPLE__
-#define PTHREAD_CREATE_THROW
-#else
-#define PTHREAD_CREATE_THROW throw()
-#endif
-
-extern "C" int pthread_create(pthread_t *thread, const pthread_attr_t *attr, mesh::PthreadFn startRoutine,
-                              void *arg) PTHREAD_CREATE_THROW {
-  return mesh::runtime().createThread(thread, attr, startRoutine, arg);
-}
-
-static void writerThread() {
-  ShouldContinueTest = 1;
-
-  for (size_t i = 1; i < numeric_limits<uint64_t>::max(); i++) {
-    if (i % 1000000 == 0 && ShouldExit)
-      return;
-
-    s1[0] = 'A';
-    s2[0] = 'Z';
-  }
-
-  debug("loop ended before ShouldExit\n");
-}
-
-// shows up in strace logs, but otherwise does nothing
-static inline void note(const char *note) {
-  int _ __attribute__((unused)) = write(-1, note, strlen(note));
-}
-
-static void meshTestConcurrentWrite(bool invert) {
-  if (!kMeshingEnabled) {
-    GTEST_SKIP();
-  }
-
-  const auto tid = gettid();
-  GlobalHeap &gheap = runtime().heap();
-
-  // disable automatic meshing for this test
-  gheap.setMeshPeriodMs(kZeroMs);
-
-  ASSERT_EQ(gheap.getAllocatedMiniheapCount(), 0UL);
-
-  FixedArray<MiniHeap, 1> array{};
-
-  // allocate three miniheaps for the same object size from our global heap
-  gheap.allocSmallMiniheaps(SizeMap::SizeClass(StrLen), StrLen, array, tid);
-  MiniHeap *mh1 = array[0];
-  array.clear();
-
-  gheap.allocSmallMiniheaps(SizeMap::SizeClass(StrLen), StrLen, array, tid);
-  MiniHeap *mh2 = array[0];
-  array.clear();
-
-  ASSERT_EQ(gheap.getAllocatedMiniheapCount(), 2UL);
-
-  // sanity checks
-  ASSERT_TRUE(mh1 != mh2);
-  ASSERT_EQ(mh1->maxCount(), mh2->maxCount());
-  ASSERT_EQ(mh1->maxCount(), ObjCount);
-
-  // allocate two c strings, one from each miniheap at different offsets
-  s1 = reinterpret_cast<char *>(mh1->mallocAt(gheap.arenaBegin(), 0));
-  s2 = reinterpret_cast<char *>(mh2->mallocAt(gheap.arenaBegin(), ObjCount - 1));
-
-  ASSERT_TRUE(s1 != nullptr);
-  ASSERT_TRUE(s2 != nullptr);
-
-  // fill in the strings, set the trailing null byte
-  memset(s1, 'A', StrLen);
-  memset(s2, 'Z', StrLen);
-  s1[StrLen - 1] = 0;
-  s2[StrLen - 1] = 0;
-
-  // copy these strings so we can check the contents after meshing
-  char *v1 = strdup(s1);
-  char *v2 = strdup(s2);
-  ASSERT_STREQ(s1, v1);
-  ASSERT_STREQ(s2, v2);
-
-  ASSERT_EQ(mh1->inUseCount(), 1UL);
-  ASSERT_EQ(mh2->inUseCount(), 1UL);
-
-  if (invert) {
-    MiniHeap *tmp = mh1;
-    mh1 = mh2;
-    mh2 = tmp;
-  }
-
-  thread writer(writerThread);
-
-  while (ShouldContinueTest != 1)
-    sched_yield();
-
-  const auto bitmap1 = mh1->bitmap().bits();
-  const auto bitmap2 = mh2->bitmap().bits();
-  const auto len = mh1->bitmap().byteCount();
-  ASSERT_EQ(len, mh2->bitmap().byteCount());
-
-  ASSERT_TRUE(mesh::bitmapsMeshable(bitmap1, bitmap2, len));
-
-  note("ABOUT TO MESH");
-  // mesh the two miniheaps together
-  gheap.meshLocked(mh1, mh2);
-  note("DONE MESHING");
-
-  // ensure the count of set bits looks right
-  ASSERT_EQ(mh1->inUseCount(), 2UL);
-
-  // check that our two allocated objects still look right
-  ASSERT_STREQ(s1, v1);
-  ASSERT_STREQ(s2, v2);
-
-  // get an aliased pointer to the second string by pointer arithmetic
-  // on the first string
-  char *s3 = s1 + (ObjCount - 1) * StrLen;
-  ASSERT_STREQ(s2, s3);
-
-  ShouldExit = 1;
-  writer.join();
-
-  // modify the second string, ensure the modification shows up on
-  // string 3 (would fail if the two miniheaps weren't meshed)
-  s2[0] = 'b';
-  ASSERT_EQ(s3[0], 'b');
-
-  // now free the objects by going through the global heap -- it
-  // should redirect both objects to the same miniheap
-  gheap.free(s1);
-  ASSERT_TRUE(!mh1->isEmpty());
-  gheap.free(s2);
-  ASSERT_TRUE(mh1->isEmpty());  // safe because mh1 isn't "done"
-
-  note("ABOUT TO FREE");
-  gheap.freeMiniheap(mh1);
-  note("DONE FREE");
-
-  note("ABOUT TO SCAVENGE");
-  gheap.scavenge(true);
-  note("DONE SCAVENGE");
-
-  ASSERT_EQ(gheap.getAllocatedMiniheapCount(), 0UL);
-}
-
-TEST(ConcurrentMeshTest, TryMesh) {
-  meshTestConcurrentWrite(false);
-}
-
-TEST(ConcurrentMeshTest, TryMeshInverse) {
-  meshTestConcurrentWrite(true);
-}