mesh-rb 0.0.1 → 0.0.2

data/ext/mesh/mesh/src/static/if.h

@@ -1,36 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-
-/**
- * @file   staticif.h
- * @brief  Statically returns a VALUE based on a conditional.
- * @author Emery Berger <http://www.cs.umass.edu/~emery>
- * @note   Copyright (C) 2005 by Emery Berger, University of Massachusetts Amherst.
- */
-
-#pragma once
-#ifndef MESH_STATIC__IF_H
-#define MESH_STATIC__IF_H
-
-template <class TYPE>
-TYPE constexpr staticif(bool v, TYPE a, TYPE b) {
-  return (v ? a : b);
-}
-
-#else
-
-template <bool b, int a, int c>
-class StaticIf;
-
-template <int a, int b>
-class StaticIf<true, a, b> {
-public:
-  enum { VALUE = a };
-};
-
-template <int a, int b>
-class StaticIf<false, a, b> {
-public:
-  enum { VALUE = b };
-};
-
-#endif

data/ext/mesh/mesh/src/static/log.h

@@ -1,43 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-
-/**
- * @file   staticlog.h
- * @brief  Statically returns the log (base 2) of a value.
- * @author Emery Berger <http://www.cs.umass.edu/~emery>
- * @note   Copyright (C) 2005 by Emery Berger, University of Massachusetts Amherst.
- */
-
-#pragma once
-#ifndef MESH_STATIC__LOG_H
-#define MESH_STATIC__LOG_H
-
-#include "if.h"
-
-int constexpr staticlog(int v) {
-  return ((v == 1) ? 0 : (v == 2) ? 1 : (v > 1) ? staticlog(v / 2) + 1 : 0);
-}
-
-#else
-
-template <int Number>
-class StaticLog;
-
-template <>
-class StaticLog<1> {
-public:
-  enum { VALUE = 0 };
-};
-
-template <>
-class StaticLog<2> {
-public:
-  enum { VALUE = 1 };
-};
-
-template <int Number>
-class StaticLog {
-public:
-  enum { VALUE = StaticIf<(Number > 1), StaticLog<Number / 2>::VALUE + 1, 0>::VALUE };
-};
-
-#endif

data/ext/mesh/mesh/src/testing/benchmark/local_refill.cc

@@ -1,103 +0,0 @@
-// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
-// 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.
-
-#include <atomic>
-#include <random>
-
-#include <benchmark/benchmark.h>
-
-#include "internal.h"
-#include "global_heap.h"
-#include "runtime.h"
-#include "shuffle_vector.h"
-
-using namespace mesh;
-
-static constexpr size_t kMiniHeapCount = 2 << 18;
-static constexpr uint32_t kObjSize = 16;
-static constexpr uint32_t kObjCount = 256;
-
-static void ATTRIBUTE_NEVER_INLINE initializeMiniHeaps(FixedArray<MiniHeap, kMiniHeapCount> &miniheaps) {
-  // https://xkcd.com/221/ ; ensure results are repeatable (each benchmark sees the same bits set)
-  static constexpr std::mt19937::result_type kSeed{3852235742};
-  auto rng = std::bind(std::uniform_int_distribution<uint64_t>{}, std::mt19937{kSeed});
-
-  for (size_t i = 0; i < kMiniHeapCount; i++) {
-    MiniHeap *mh = miniheaps[i];
-
-    // this is way way faster than setting each individual bit
-    auto bits = mh->writableBitmap().mut_bits();
-    for (size_t j = 0; j < 4; j++) {
-      bits[j] = rng();
-    }
-  }
-}
-
-static void ATTRIBUTE_NEVER_INLINE initAndRefill(FixedArray<MiniHeap, kMiniHeapCount> &array, size_t &n,
-                                                 ShuffleVector &sv) {
-  {
-    FixedArray<MiniHeap, kMaxMiniheapsPerShuffleVector> &miniheaps = sv.miniheaps();
-    miniheaps.clear();
-    for (size_t i = 0; i < kMaxMiniheapsPerShuffleVector; i++) {
-      miniheaps.append(array[n++]);
-      hard_assert(n < kMiniHeapCount);
-    }
-  }
-  sv.reinit();
-
-  bool cont = true;
-  // it may take a few iterations to pull the available offsets from our miniheaps
-  while (likely(cont)) {
-    while (likely(!sv.isExhausted())) {
-      char *ptr = reinterpret_cast<char *>(sv.malloc());
-      hard_assert(ptr != nullptr);
-      ptr[0] = 'x';
-    }
-
-    cont = sv.localRefill();
-  }
-}
-
-static void BM_LocalRefill1(benchmark::State &state) {
-  mesh::debug("local refill test!\n");
-  const auto tid = gettid();
-  GlobalHeap &gheap = runtime().heap();
-
-  // disable automatic meshing for this test
-  gheap.setMeshPeriodMs(kZeroMs);
-
-  static FixedArray<MiniHeap, kMiniHeapCount> array{};
-  if (array.size() == 0) {
-    const size_t initialAllocCount = gheap.getAllocatedMiniheapCount();
-    hard_assert_msg(initialAllocCount == 0UL, "expected 0 initial MHs, not %zu", initialAllocCount);
-
-    // allocate two miniheaps for the same object size from our global heap
-    gheap.allocSmallMiniheaps(SizeMap::SizeClass(kObjSize), kObjSize, array, tid);
-    mesh::debug("initializing the miniheaps\n");
-  }
-
-  // always reinitialize the bitmaps (will be same pattern each time)
-  initializeMiniHeaps(array);
-
-  ShuffleVector sv{};
-  sv.initialInit(gheap.arenaBegin(), kObjSize);
-
-  size_t n = 0;
-
-  for (auto _ : state) {
-    initAndRefill(array, n, sv);
-  }
-
-  // for (size_t i = 0; i < kMiniHeapCount; i++) {
-  //   MiniHeap *mh = array[i];
-  //   gheap.freeMiniheap(mh);
-  // }
-  // array.clear();
-
-  sv.miniheaps().clear();
-}
-BENCHMARK(BM_LocalRefill1);
-
-BENCHMARK_MAIN();

data/ext/mesh/mesh/src/testing/big-alloc.c

@@ -1,28 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define SZ 32816
-#define NOBJS 40
-
-volatile char *volatile var;
-
-int main() {
-  char *objects[NOBJS];
-  memset(objects, 0, sizeof(*objects) * NOBJS);
-
-  for (size_t i = 0; i < 1000000; i++) {
-    var = malloc(SZ);
-    memset((char *)var, 0x55, SZ);
-    size_t off = i % NOBJS;
-    if (objects[off] != NULL)
-      free(objects[off]);
-    objects[off] = (char *)var;
-    var = NULL;
-  }
-
-  for (size_t i = 0; i < NOBJS; i++) {
-    if (objects[i] != NULL)
-      free(objects[i]);
-  }
-}

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

@@ -1,128 +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 <unistd.h>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "measure_rss.h"
-
-void print_rss() {
-  printf("\trss:\t%10.3f MB\n", get_rss_kb() / 1024.0);
-}
-
-extern "C" {
-int mesh_mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen);
-}
-
-using std::string;
-
-// use as (voidptr)ptr -- disgusting, but useful to minimize the clutter
-// around using volatile.
-#define voidptr void *)(intptr_t
-#define NOINLINE __attribute__((noinline))
-#define MESH_MARKER (7305126540297948313)
-#define MB (1024 * 1024)
-#define GB (1024 * 1024 * 1024)
-
-void *NOINLINE bench_alloc(size_t n) {
-  volatile void *ptr = malloc(n);
-  for (size_t i = 0; i < n; i++) {
-    ((char *)ptr)[i] = lrand48() & 0xff;
-  }
-
-  return (voidptr)ptr;
-}
-
-void NOINLINE bench_free(void *ptr) {
-  free(ptr);
-}
-
-// Fig 4. "A Basic Strategy" from http://www.ece.iastate.edu/~morris/papers/10/ieeetc10.pdf
-void NOINLINE basic_fragment(int64_t n, size_t m_total) {
-  int64_t ci = 1;
-  int64_t m_avail = m_total;
-  size_t m_usage = 0;  // S_t in the paper
-  size_t retained_off = 0;
-
-  const size_t ptr_table_len = 2 * m_total / (ci * n);
-  // fprintf(stdout, "ptr_table_len: %zu\n", ptr_table_len);
-  volatile char *volatile *ptr_table =
-      reinterpret_cast<volatile char *volatile *>(bench_alloc(ptr_table_len * sizeof(char *)));
-  volatile char *volatile *retained_table =
-      reinterpret_cast<volatile char *volatile *>(bench_alloc(ptr_table_len * sizeof(char *)));
-  memset((voidptr)retained_table, 0, ptr_table_len * sizeof(char *));
-
-  // show how much RSS we just burned through for the table of
-  // pointers we just allocated
-  print_rss();
-
-  for (int64_t i = 1; m_avail >= 2 * ci * n; i++) {
-    ci *= 2;
-    // number of allocation pairs in this iteration
-    const size_t pi = m_avail / (2 * ci * n);
-
-    fprintf(stderr, "i:%4lld, ci:%5lld, n:%5lld, pi:%7zu (osize:%5lld)\n", (long long int)i, (long long int)ci,
-            (long long int)n, pi, (long long int)(ci * n));
-
-    // allocate two objects
-    for (size_t k = 0; k < pi; k++) {
-      ptr_table[2 * k + 0] = reinterpret_cast<volatile char *>(bench_alloc(ci * n));
-      ptr_table[2 * k + 1] = reinterpret_cast<volatile char *>(bench_alloc(ci * n));
-    }
-
-    m_usage += ci * n * pi;
-
-    // now free every other object
-    for (size_t k = 0; k < pi; k++) {
-      retained_table[retained_off++] = ptr_table[2 * k + 0];
-      bench_free((voidptr)ptr_table[2 * k + 1]);
-    }
-
-    m_avail -= ci * n * pi;
-  }
-
-  fprintf(stderr, "allocated (and not freed) %f MB\n", ((double)m_usage) / MB);
-
-  print_rss();
-
-  // mesh_mallctl("mesh.scavenge", nullptr, nullptr, nullptr, 0);
-
-  print_rss();
-
-  for (size_t i = 0; i < ptr_table_len; i++) {
-    bench_free((voidptr)retained_table[i]);
-  }
-
-  print_rss();
-
-  bench_free((voidptr)ptr_table);
-  bench_free((voidptr)retained_table);
-
-  // mesh_mallctl("mesh.scavenge", nullptr, nullptr, nullptr, 0);
-}
-
-int main(int argc, char *argv[]) {
-  print_rss();
-
-  basic_fragment(512, 128 * MB);
-
-  print_rss();
-  // char *env = getenv("LD_PRELOAD");
-  // if (env && strstr(env, "libmesh.so") != NULL) {
-  //   fprintf(stderr, "meshing stuff\n");
-  //   free((void *)MESH_MARKER);
-  // }
-
-  // print_rss();
-
-  // sleep(700);
-
-  return 0;
-}

data/ext/mesh/mesh/src/testing/global-large-stress.cc

@@ -1,25 +0,0 @@
-#include <cstdio>
-#include <cstdlib>
-#include <vector>
-
-static constexpr size_t kMinAllocSz = 800000;
-static constexpr size_t kMaxAllocSz = 900000;
-static constexpr unsigned kMaxLiveAlloc = 128;  // keep no more than 128 * kMaxAllocSz memory allocated.
-
-int main(void) {
-  std::vector<void *> alloc(kMaxLiveAlloc, nullptr);
-  for (size_t i = 0; i < kMaxLiveAlloc; i++) {
-    if (alloc[i] != nullptr) {
-      fprintf(stderr, "alloc not zero initialized!\n");
-    }
-  }
-
-  while (1) {
-    const size_t ix = rand() % kMaxLiveAlloc;
-    const size_t sz = (rand() % (kMaxAllocSz - kMinAllocSz)) + kMinAllocSz;
-
-    free(alloc[ix]);
-    alloc[ix] = malloc(sz);
-  }
-  return 0;
-}

data/ext/mesh/mesh/src/testing/local-alloc.c

@@ -1,16 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define SZ 61
-
-volatile char *volatile var;
-
-int main() {
-  for (size_t i = 0; i < 200000000; i++) {
-    var = malloc(SZ);
-    /* memset((char *)var, 0, SZ); */
-    free((void *)var);
-    var = NULL;
-  }
-}

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

@@ -1,189 +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 <cstdio>
-#include <cstring>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#if defined(__APPLE__)
-#include <libgen.h>
-#endif
-
-#include "internal.h"
-
-#include "bitmap.h"
-#include "meshing.h"
-
-using mesh::internal::Bitmap;
-using std::make_unique;
-using std::stoi;
-using std::string;
-using std::unique_ptr;
-using std::vector;
-
-// https://stackoverflow.com/questions/236129/split-a-string-in-c
-template <typename Out>
-void split(const std::string &s, char delim, Out result) {
-  std::stringstream ss;
-  ss.str(s);
-  std::string item;
-  while (std::getline(ss, item, delim)) {
-    *(result++) = item;
-  }
-}
-
-// https://stackoverflow.com/questions/236129/split-a-string-in-c
-std::vector<std::string> split(const std::string &s, char delim) {
-  std::vector<std::string> elems;
-  split(s, delim, std::back_inserter(elems));
-  return elems;
-}
-
-class MeshTestcase {
-public:
-  explicit MeshTestcase(int length, int occupancy, int nStrings, string method)
-      : length(static_cast<size_t>(length)),
-        occupancy(static_cast<size_t>(occupancy)),
-        nStrings(static_cast<size_t>(nStrings)),
-        method(method) {
-    d_assert(length > 0);
-    d_assert(occupancy > 0);
-    d_assert(nStrings > 0);
-  }
-  vector<Bitmap> bitmaps{};
-  vector<mesh::internal::string> strings{};
-
-  size_t length;  // string length
-  size_t occupancy;
-  size_t nStrings;
-  string method;
-
-  ssize_t expectedResult{-1};
-};
-
-unique_ptr<MeshTestcase> openTestcase(const char *path) {
-  FILE *f = fopen(path, "r");
-  if (f == nullptr) {
-    fprintf(stderr, "ERROR: couldn't open testcase %s: %s\n", path, strerror(errno));
-    exit(1);
-  }
-
-  auto *bname = basename((char *)path);
-  auto *fname = strdup(bname);
-  auto *dotPos = strrchr(fname, '.');
-  // remove the extension if it exists
-  if (dotPos) {
-    *dotPos = 0;
-  }
-
-  vector<string> parts = split(fname, ',');
-  if (parts.size() != 4) {
-    fprintf(stderr, "ERROR: expected filename to have 4 parts before extension: %s\n", path);
-    exit(1);
-  }
-  free(fname);
-
-  auto testcase = make_unique<MeshTestcase>(stoi(parts[0]), stoi(parts[1]), stoi(parts[2]), parts[3]);
-
-  bool loop = true;
-  while (loop) {
-    char *line = nullptr;
-    size_t n = 0;
-    ssize_t len = getline(&line, &n, f);
-    if ((len < 0 && !errno) || len == 0) {
-      if (line)
-        free(line);
-      fprintf(stderr, "ERROR: unexpected end of testcase\n");
-      exit(1);
-    } else if (len < 0) {
-      fprintf(stderr, "ERROR: getline: %s\n", strerror(errno));
-      exit(1);
-    }
-    d_assert(line != nullptr);
-
-    d_assert(len > 0);
-    if (line[len - 1] == '\n') {
-      line[len - 1] = 0;
-      len--;
-    }
-
-    d_assert(len > 0);
-    if (line[len - 1] == '\r') {
-      line[len - 1] = 0;
-      len--;
-    }
-
-    d_assert(len > 0);
-    if (line[0] == '-') {
-      testcase->expectedResult = stoi(&line[1]);
-      loop = false;
-    } else {
-      mesh::internal::string sline{line};
-      d_assert(sline.length() == testcase->length);
-
-      testcase->bitmaps.emplace_back(sline);
-      testcase->strings.emplace_back(sline);
-
-      d_assert_msg(sline == testcase->bitmaps.back().to_string(sline.length()), "expected roundtrip '%s' == '%s'", line,
-                   testcase->bitmaps.back().to_string().c_str());
-    }
-    free(line);
-  }
-  fclose(f);
-
-  d_assert_msg(testcase->strings.size() == testcase->nStrings, "%zu == %zu", testcase->strings.size(),
-               testcase->nStrings);
-  d_assert(testcase->expectedResult >= 0);
-
-  return testcase;
-}
-
-bool validate(const unique_ptr<MeshTestcase> &testcase) {
-  ssize_t result = 0;
-  if (testcase->method == "dumb") {
-    // result = mesh::method::simple(testcase->bitmaps);
-    printf("TODO: implement new shifted splitting method here\n");
-    if (result == testcase->expectedResult)
-      return true;
-  } else {
-    printf("ERROR: unimplemented method '%s'\n", testcase->method.c_str());
-    return false;
-  }
-
-  if (result != testcase->expectedResult) {
-    printf("ERROR: unexpected result %zu (expected %zu) for %s method\n", result, testcase->expectedResult,
-           testcase->method.c_str());
-  }
-  return false;
-}
-
-int main(int argc, char *argv[]) {
-  if (argc > 1 && ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0))) {
-    fprintf(stderr, "Reads in string dumps and attempts to mesh.\n\n");
-    fprintf(stderr, "USAGE: %s DUMP_FILE\n", basename(argv[0]));
-    exit(0);
-  }
-
-  if (argc <= 1) {
-    fprintf(stderr, "ERROR: expected at least one filename pointing to a dump.\n");
-    exit(1);
-  }
-
-  for (auto i = 1; i < argc; ++i) {
-    printf("meshing strings from %s\n", argv[i]);
-
-    auto testcase = openTestcase(argv[i]);
-
-    if (!validate(testcase)) {
-      printf("%s: failed to validate.\n", argv[i]);
-      exit(1);
-    }
-  }
-
-  return 0;
-}