C++ (Cpp) BenchmarkSuspender Examples

Example #1

File: ThriftVsProtoBufBench.cpp Project: facebook/fbthrift

void writeBench(size_t iter) {
  BenchmarkSuspender susp;
  auto strct = create<Struct>();
  susp.dismiss();
  while (iter--) {
    IOBufQueue q;
    Serializer::serialize(strct, &q);
    folly::doNotOptimizeAway(q);
  }
  susp.rehire();
}

Example #2

File: ProtocolBench.cpp Project: ConfusedReality/pkg_serialization_fbthrift

void writeBench(size_t iters) {
  BenchmarkSuspender susp;
  auto strct = create<Struct>();
  susp.dismiss();

  while (iters--) {
    IOBufQueue q;
    Serializer::serialize(strct, &q);
  }
  susp.rehire();
}

Example #3

File: ThriftVsProtoBufBench.cpp Project: facebook/fbthrift

void writeBench(size_t iter) {
  BenchmarkSuspender susp;
  auto strct = create<Struct>();
  susp.dismiss();

  string s;
  while (iter--) {
    strct.SerializeToString(&s);
    s.clear();
  }

  susp.rehire();
}

Example #4

File: ProtocolBench.cpp Project: ConfusedReality/pkg_serialization_fbthrift

void readBench(size_t iters) {
  BenchmarkSuspender susp;
  auto strct = create<Struct>();
  IOBufQueue q;
  Serializer::serialize(strct, &q);
  auto buf = q.move();
  susp.dismiss();

  while (iters--) {
    Struct data;
    Serializer::deserialize(buf.get(), data);
  }
  susp.rehire();
}

Example #5

File: ThriftVsProtoBufBench.cpp Project: facebook/fbthrift

void readBench(size_t iter) {
  BenchmarkSuspender susp;
  auto strct = create<Struct>();
  string s;
  strct.SerializeToString(&s);

  susp.dismiss();

  while (iter--) {
    Struct data;
    data.ParseFromString(s);
    folly::doNotOptimizeAway(data);
  }
  susp.rehire();
}

Example #6

File: RxBenchmark.cpp Project: IYABAO/folly

void observe(uint iters, int N) {
  for (uint iter = 0; iter < iters; iter++) {
    BenchmarkSuspender bs;
    Subject<int> subject;
    std::vector<std::unique_ptr<Observer<int>>> observers;
    for (int i = 0; i < N; i++) {
      observers.push_back(makeObserver());
    }
    bs.dismiss();
    for (int i = 0; i < N; i++) {
      subject.observe(std::move(observers[i]));
    }
    bs.rehire();
  }
}

Example #7

File: RxBenchmark.cpp Project: IYABAO/folly

void notifyInlineObservers(uint iters, int N) {
  for (uint iter = 0; iter < iters; iter++) {
    BenchmarkSuspender bs;
    Subject<int> subject;
    std::vector<Observer<int>*> observers;
    for (int i = 0; i < N; i++) {
      observers.push_back(makeObserver().release());
    }
    for (int i = 0; i < N; i++) {
      subject.observe(observers[i]);
    }
    bs.dismiss();
    subject.onNext(42);
    bs.rehire();
  }
}

Example #8

File: TimeseriesBenchmark.cpp Project: HunterChen/folly

void addValue(unsigned int iters,
              seconds duration, size_t numBuckets,
              size_t callsPerSecond) {
  BenchmarkSuspender suspend;
  BucketedTimeSeries<int64_t> ts(numBuckets, duration);
  suspend.dismiss();

  seconds currentTime(1342000000);
  size_t timeCounter = 0;
  for (unsigned int n = 0; n < iters; ++n, ++timeCounter) {
    if (timeCounter >= callsPerSecond) {
      timeCounter = 0;
      ++currentTime;
    }
    ts.addValue(currentTime, n);
  }
}

Example #9

File: RxBenchmark.cpp Project: IYABAO/folly

void notifySubscribers(uint iters, int N) {
  for (uint iter = 0; iter < iters; iter++) {
    BenchmarkSuspender bs;
    Subject<int> subject;
    std::vector<std::unique_ptr<Observer<int>>> observers;
    std::vector<Subscription<int>> subscriptions;
    subscriptions.reserve(N);
    for (int i = 0; i < N; i++) {
      observers.push_back(makeObserver());
    }
    for (int i = 0; i < N; i++) {
      subscriptions.push_back(subject.subscribe(std::move(observers[i])));
    }
    bs.dismiss();
    subject.onNext(42);
    bs.rehire();
  }
}

Example #10

File: RxBenchmark.cpp Project: IYABAO/folly

void subscribeImpl(uint iters, int N, bool countUnsubscribe) {
  for (uint iter = 0; iter < iters; iter++) {
    BenchmarkSuspender bs;
    Subject<int> subject;
    std::vector<std::unique_ptr<Observer<int>>> observers;
    std::vector<Subscription<int>> subscriptions;
    subscriptions.reserve(N);
    for (int i = 0; i < N; i++) {
      observers.push_back(makeObserver());
    }
    bs.dismiss();
    for (int i = 0; i < N; i++) {
      subscriptions.push_back(subject.subscribe(std::move(observers[i])));
    }
    if (countUnsubscribe) {
      subscriptions.clear();
    }
    bs.rehire();
  }
}