TDigestBenchmark.cpp File Reference

#include <folly/stats/TDigest.h>
#include <algorithm>
#include <chrono>
#include <random>
#include <folly/Benchmark.h>
#include <folly/portability/GFlags.h>

Go to the source code of this file.

Functions
void	merge (unsigned int iters, size_t maxSize, size_t bufSize)
void	mergeDigests (unsigned int iters, size_t maxSize, size_t nDigests)
void	estimateQuantile (unsigned int iters, size_t maxSize, double quantile)
	BENCHMARK_DRAW_LINE ()
int	main (int argc, char *argv[])

Function Documentation

BENCHMARK_DRAW_LINE

(

)

Referenced by estimateQuantile().

void estimateQuantile	(	unsigned int	iters,
		size_t	maxSize,
		double	quantile
	)

Definition at line 76 of file TDigestBenchmark.cpp.

References BENCHMARK_DRAW_LINE(), BENCHMARK_NAMED_PARAM, BENCHMARK_RELATIVE_NAMED_PARAM, BENCHMARK_SUSPEND, buffer(), count, folly::TDigest::estimateQuantile(), generator, i, merge(), folly::TDigest::merge(), mergeDigests(), now(), and values().

                                                                           {
  TDigest digest(maxSize);

  size_t bufSize = maxSize * 10;
  BENCHMARK_SUSPEND {
    std::vector<double> values;

    std::default_random_engine generator;
    generator.seed(std::chrono::system_clock::now().time_since_epoch().count());

    std::lognormal_distribution<double> distribution(0.0, 1.0);

    for (size_t i = 0; i < 50000; ++i) {
      values.push_back(distribution(generator));
    }

    for (size_t i = 0; i < 50000 / bufSize; ++i) {
      std::vector<double> buffer;
      for (size_t j = 0; j < bufSize; ++j) {
        buffer.push_back(values[i * bufSize + j]);
      }
      digest = digest.merge(buffer);
    }
  }

  for (size_t i = 0; i < iters; ++i) {
    digest.estimateQuantile(quantile);
  }
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 169 of file TDigestBenchmark.cpp.

References argv, and folly::runBenchmarks().

                                 {
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  folly::runBenchmarks();
  return 0;
}

void merge	(	unsigned int	iters,
		size_t	maxSize,
		size_t	bufSize
	)

Definition at line 27 of file TDigestBenchmark.cpp.

References BENCHMARK_SUSPEND, buffer(), count, generator, i, folly::TDigest::merge(), folly::gen::move, now(), and folly::presorted.

Referenced by folly::detail::DigestBuilder< DigestT >::build(), estimateQuantile(), mergeDigests(), folly::detail::BufferedDigest< DigestT, ClockT >::onNewDigest(), folly::detail::BufferedSlidingWindow< DigestT, ClockT >::onNewDigest(), and TEST().

                                                               {
  TDigest digest(maxSize);

  std::vector<std::vector<double>> buffers;

  BENCHMARK_SUSPEND {
    std::default_random_engine generator;
    generator.seed(std::chrono::system_clock::now().time_since_epoch().count());

    std::lognormal_distribution<double> distribution(0.0, 1.0);

    for (size_t i = 0; i < iters; ++i) {
      std::vector<double> buffer;
      for (size_t j = 0; j < bufSize; ++j) {
        buffer.push_back(distribution(generator));
      }
      std::sort(buffer.begin(), buffer.end());
      buffers.push_back(std::move(buffer));
    }
  }

  for (const auto& buffer : buffers) {
    digest = digest.merge(folly::presorted, buffer);
  }
}

void mergeDigests	(	unsigned int	iters,
		size_t	maxSize,
		size_t	nDigests
	)

Definition at line 53 of file TDigestBenchmark.cpp.

References BENCHMARK_SUSPEND, buffer(), count, generator, i, merge(), folly::TDigest::merge(), and now().

Referenced by estimateQuantile().

                                                                       {
  std::vector<TDigest> digests;
  BENCHMARK_SUSPEND {
    TDigest digest(maxSize);
    std::default_random_engine generator;
    generator.seed(std::chrono::system_clock::now().time_since_epoch().count());

    std::lognormal_distribution<double> distribution(0.0, 1.0);

    for (size_t i = 0; i < nDigests; ++i) {
      std::vector<double> buffer;
      for (size_t j = 0; j < maxSize; ++j) {
        buffer.push_back(distribution(generator));
      }
      digests.push_back(digest.merge(buffer));
    }
  }

  for (size_t i = 0; i < iters; ++i) {
    TDigest::merge(digests);
  }
}