single threaded test framework

- mixer selects which producers to run
- two different producers with different allocation patterns

Author: Tyler Etzel

CMakeLists.txt

@@ -6,3 +6,7 @@ find_package(Threads)
 add_executable(memsetVsMadvise memsetVsMadvise.cpp)
 set_property(TARGET memsetVsMadvise PROPERTY CXX_STANDARD 11)
 target_link_libraries(memsetVsMadvise PRIVATE ${CMAKE_THREAD_LIBS_INIT} gflags)
+
+add_executable(stress stress_test/Main.cpp stress_test/Producers.cpp stress_test/Mixer.cpp)
+set_property(TARGET stress PROPERTY CXX_STANDARD 14)
+target_link_libraries(stress PRIVATE gflags)

stress_test/Main.cpp

@@ -0,0 +1,30 @@
+#include <chrono>
+#include <iostream>
+#include <vector>
+
+#include <gflags/gflags.h>
+
+#include "Mixer.h"
+
+DEFINE_int32(num_producers, 100, "number of producers to run");
+
+int main(int argc, char **argv) {
+
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  vector<std::unique_ptr<Producer>> producers;
+  producers.push_back(std::move(std::make_unique<SimpleProducer>(8, 100000)));
+  producers.push_back(std::move(std::make_unique<VectorProducer>(
+      100000, std::chrono::duration<double>(1.0))));
+
+  using namespace std::chrono;
+
+  Mixer m(std::move(producers), FLAGS_num_producers);
+
+  high_resolution_clock::time_point beginTime = high_resolution_clock::now();
+  m.run();
+  high_resolution_clock::time_point endTime = high_resolution_clock::now();
+
+  duration<double> span = duration_cast<duration<double>>(endTime - beginTime);
+  std::cout << "Elapsed time: " << span.count() << std::endl;
+}

stress_test/Mixer.cpp

@@ -0,0 +1,34 @@
+#include "Mixer.h"
+
+Mixer::Mixer(vector<unique_ptr<Producer>> producers, int numProducers)
+    : producers_(move(producers)), producersRemaining_(numProducers),
+      producerIndexPicker_(0, this->producers_.size() - 1) {}
+
+// Picks next producer for the mixer to run. Currently uniform random choice
+const Producer &Mixer::pick() {
+  int producerIndex = this->producerIndexPicker_(this->generator_);
+  return *(this->producers_[producerIndex]);
+}
+
+void Mixer::run() {
+  while (this->producersRemaining_ > 0) {
+    if (this->allocated_.size() > 0 &&
+        this->allocated_.back().freeAfter() <
+            std::chrono::high_resolution_clock::now()) {
+			// deallocate something if it's lifetime has expired
+      this->allocated_.pop_back();
+    } else {
+			// otherwise run a random producer
+      Allocation a = this->pick().run();
+      if (!a.isEmpty()) {
+        this->allocated_.push_back(std::move(a));
+        sort(rbegin(this->allocated_), rend(this->allocated_));
+      }
+      producersRemaining_--;
+    }
+  }
+  // cleanup remaining allocated things immediately, regardless of lifetime
+  while (!this->allocated_.empty()) {
+    this->allocated_.pop_back();
+  }
+}

stress_test/Mixer.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <random>
+#include <vector>
+
+#include "Producers.h"
+
+using std::unique_ptr;
+using std::vector;
+
+class Mixer {
+public:
+  void run();
+  Mixer(vector<unique_ptr<Producer>> producers, int numProducers);
+
+private:
+  /* maintains reverse-sorted order by lifetime; i.e. [push_back] yields the
+   * allocation that should be deallocated the soonest */
+  vector<Allocation> allocated_;
+  vector<unique_ptr<Producer>> producers_;
+  int producersRemaining_;
+  const Producer &pick();
+  std::uniform_int_distribution<int> producerIndexPicker_;
+  std::default_random_engine generator_;
+};

stress_test/Producers.cpp

@@ -0,0 +1,77 @@
+#include "Producers.h"
+
+#include <iostream>
+
+// Allocation
+
+bool Allocation::operator<(const Allocation &that) const {
+  return this->toFree_ < that.toFree_;
+}
+
+bool Allocation::isEmpty() const { return this->toFree_.size() == 0; }
+
+std::chrono::high_resolution_clock::time_point Allocation::freeAfter() const {
+  return this->freeAfter_;
+}
+
+Allocation::Allocation(std::vector<void *> toFree,
+                       std::chrono::high_resolution_clock::time_point freeAfter)
+    : toFree_(toFree), freeAfter_(freeAfter) {}
+
+Allocation::~Allocation() {
+  for (auto it = begin(this->toFree_); it != end(this->toFree_); ++it) {
+    free(*it);
+  }
+}
+
+// Simple Producer
+
+SimpleProducer::SimpleProducer(int allocSize, int numAllocs)
+    : allocSize_(allocSize), numAllocs_(numAllocs) {}
+
+Allocation SimpleProducer::run() const {
+  for (int i = 0; i < this->numAllocs_; i++) {
+    char *ptr = (char *)calloc(this->allocSize_, sizeof(char));
+    if (ptr == NULL) {
+      std::cout << "allocation failed" << std::endl;
+    }
+    free(ptr);
+  }
+  return std::move(Allocation());
+}
+
+void swap(Allocation &a1, Allocation &a2) {
+	a1.toFree_.swap(a2.toFree_);
+	std::swap(a1.freeAfter_, a2.freeAfter_);
+}
+
+// Vector Producer
+
+VectorProducer::VectorProducer(int vectorSize,
+                               std::chrono::duration<double> lifetime)
+    : vectorSize_(vectorSize), lifetime_(lifetime), shouldFree_(true) {}
+
+VectorProducer::VectorProducer(int vectorSize)
+    : vectorSize_(vectorSize), lifetime_(0.0), shouldFree_(true) {}
+
+Allocation VectorProducer::run() const {
+  void *ptr = malloc(1);
+  size_t currSize = 1;
+  while (currSize < this->vectorSize_) {
+    free(ptr);
+    currSize *= 2;
+    ptr = malloc(currSize);
+  }
+  if (this->shouldFree_) {
+    free(ptr);
+    return Allocation();
+  } else {
+
+    using namespace std::chrono;
+    high_resolution_clock::time_point t = high_resolution_clock::now();
+    high_resolution_clock::duration d =
+        duration_cast<high_resolution_clock::duration>(this->lifetime_);
+    t += d;
+    return std::move(Allocation(std::vector<void *>({ptr}), t));
+  }
+}

stress_test/Producers.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <chrono>
+#include <vector>
+
+class Allocation {
+public:
+  // sorts based on [freeAfter] field
+  bool operator<(const Allocation &that) const;
+  // true iff [this->toFree_] is empty
+  bool isEmpty() const;
+  std::chrono::high_resolution_clock::time_point freeAfter() const;
+  Allocation(std::vector<void *> toFree,
+             std::chrono::high_resolution_clock::time_point freeAfter);
+  // makes an allocation such that [isEmpty()] is true
+  Allocation() = default;
+
+  // Disable copy constructor: whoever owns the Allocation should deallocate it
+  Allocation(Allocation const &) = delete;
+  Allocation &operator=(Allocation const &) = delete;
+
+	// must define a move constructor since we deleted the copy constructor
+	Allocation(Allocation&&) = default;
+	Allocation& operator=(Allocation&&) = default;
+
+	// The destructor deallocates the memory in [toFree_]
+  ~Allocation();
+
+	// needed to sort
+	friend void swap(Allocation &a1, Allocation &a2);
+
+private:
+  std::vector<void *> toFree_;
+  // absolute time after which this should be freed
+  std::chrono::high_resolution_clock::time_point freeAfter_;
+};
+
+class Producer {
+public:
+  virtual Allocation run() const = 0;
+};
+
+// allocates a vector of size [sz] and then frees it
+class VectorProducer : public Producer {
+public:
+  Allocation run() const;
+  // allocate, and then free after [lifetime] has elapsed
+  VectorProducer(int vectorSize, std::chrono::duration<double> lifetime);
+  // allocate and then free immediately
+  VectorProducer(int vectorSize);
+
+private:
+  int vectorSize_;
+  std::chrono::duration<double> lifetime_;
+  bool shouldFree_;
+};
+
+/* allocates a block of size [alloc_sz], and then immediately frees it. Repeats
+ * this [n_allocs] times. */
+class SimpleProducer : public Producer {
+public:
+  Allocation run() const;
+  SimpleProducer(int allocSize, int numAllocs);
+
+private:
+  int allocSize_;
+  int numAllocs_;
+};