QueueAppenderBenchmark.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/Format.h>
#include <folly/Range.h>
#include <folly/io/Cursor.h>
#include <folly/io/IOBufQueue.h>

Go to the source code of this file.

Functions
	DECLARE_bool (benchmark)
template<class T >
void	runArithmeticBench (int64_t iters)
	BENCHMARK (write_uint8, iters)
	BENCHMARK (write_uint16, iters)
	BENCHMARK (write_uint32, iters)
void	runPushBenchmark (int64_t iters, const std::string &str)
	BENCHMARK (push_64b, iters)
	BENCHMARK (push_1024b, iters)
	BENCHMARK (append, iters)
void	preallocate_postallocate_bench (int64_t iters, size_t size)
	BENCHMARK (preallocate_postallocate_1b, iters)
	BENCHMARK (preallocate_postallocate_4b, iters)
	BENCHMARK (preallocate_postallocate_32b, iters)
	BENCHMARK (preallocate_postallocate_256b, iters)
int	main (int argc, char **argv)

Variables
constexpr size_t	kBenchmarkSize = 4096

Function Documentation

BENCHMARK	(	write_uint8	,
		iters
	)

Definition at line 41 of file QueueAppenderBenchmark.cpp.

                              {
  runArithmeticBench<uint8_t>(iters);
}

BENCHMARK	(	write_uint16	,
		iters
	)

Definition at line 45 of file QueueAppenderBenchmark.cpp.

                               {
  runArithmeticBench<uint16_t>(iters);
}

BENCHMARK	(	write_uint32	,
		iters
	)

Definition at line 49 of file QueueAppenderBenchmark.cpp.

                               {
  runArithmeticBench<uint32_t>(iters);
}

BENCHMARK	(	push_64b	,
		iters
	)

Definition at line 65 of file QueueAppenderBenchmark.cpp.

References BENCHMARK_SUSPEND, folly::data(), runPushBenchmark(), and string.

                           {
  std::string data;
  BENCHMARK_SUSPEND {
    data = std::string(64, 'f');
  }
  runPushBenchmark(iters, data);
}

BENCHMARK	(	push_1024b	,
		iters
	)

Definition at line 73 of file QueueAppenderBenchmark.cpp.

References BENCHMARK_SUSPEND, folly::data(), runPushBenchmark(), and string.

                             {
  std::string data;
  BENCHMARK_SUSPEND {
    data = std::string(1024, 'b');
  }
  runPushBenchmark(iters, data);
}

BENCHMARK	(	append	,
		iters
	)

Definition at line 81 of file QueueAppenderBenchmark.cpp.

References folly::IOBuf::append(), BENCHMARK_SUSPEND, folly::IOBuf::clone(), folly::IOBuf::create(), folly::doNotOptimizeAway(), i, folly::io::QueueAppender::insert(), kBenchmarkSize, and folly::IOBufQueue::move().

                         {
  constexpr size_t kNumAppendPerIter = 1024;

  std::unique_ptr<folly::IOBuf> largeBuffer;
  BENCHMARK_SUSPEND {
    largeBuffer = folly::IOBuf::create(1024);
    largeBuffer->append(1024);
  }

  while (iters--) {
    folly::IOBufQueue queue;
    QueueAppender appender(&queue, kBenchmarkSize);
    for (size_t i = 0; i < kNumAppendPerIter; ++i) {
      appender.insert(largeBuffer->clone());
    }
    folly::doNotOptimizeAway(queue.move());
  }
}

BENCHMARK	(	preallocate_postallocate_1b	,
		iters
	)

Definition at line 116 of file QueueAppenderBenchmark.cpp.

References preallocate_postallocate_bench().

                                              {
  preallocate_postallocate_bench(iters, 1);
}

BENCHMARK	(	preallocate_postallocate_4b	,
		iters
	)

Definition at line 120 of file QueueAppenderBenchmark.cpp.

References preallocate_postallocate_bench().

                                              {
  preallocate_postallocate_bench(iters, 4);
}

BENCHMARK	(	preallocate_postallocate_32b	,
		iters
	)

Definition at line 124 of file QueueAppenderBenchmark.cpp.

References preallocate_postallocate_bench().

                                               {
  preallocate_postallocate_bench(iters, 32);
}

BENCHMARK	(	preallocate_postallocate_256b	,
		iters
	)

Definition at line 128 of file QueueAppenderBenchmark.cpp.

References preallocate_postallocate_bench().

                                                {
  preallocate_postallocate_bench(iters, 256);
}

DECLARE_bool

(

benchmark

)

int main	(	int	argc,
		char **	argv
	)

Definition at line 132 of file QueueAppenderBenchmark.cpp.

References folly::runBenchmarks().

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

void preallocate_postallocate_bench	(	int64_t	iters,
		size_t	size
	)

Definition at line 100 of file QueueAppenderBenchmark.cpp.

References BENCHMARK_SUSPEND, folly::data(), folly::doNotOptimizeAway(), i, kBenchmarkSize, folly::IOBufQueue::move(), folly::IOBufQueue::postallocate(), folly::IOBufQueue::preallocate(), folly::range(), folly::size(), and string.

Referenced by BENCHMARK().

                                                                {
  std::string data;
  BENCHMARK_SUSPEND {
    data = std::string(size, 'f');
  }
  while (iters--) {
    folly::IOBufQueue queue;
    for (size_t i = 0; i < kBenchmarkSize; ++i) {
      auto range = queue.preallocate(size, kBenchmarkSize);
      memcpy(range.first, data.data(), size);
      queue.postallocate(size);
    }
    folly::doNotOptimizeAway(queue.move());
  }
}

template<class T >

void runArithmeticBench

(

int64_t

iters

)

Definition at line 30 of file QueueAppenderBenchmark.cpp.

References folly::doNotOptimizeAway(), i, kBenchmarkSize, folly::IOBufQueue::move(), folly::T, and folly::io::QueueAppender::write().

                                       {
  while (iters--) {
    folly::IOBufQueue queue;
    QueueAppender appender(&queue, kBenchmarkSize);
    for (size_t i = 0; i < kBenchmarkSize / sizeof(T); ++i) {
      appender.write((T)0xFB);
    }
    folly::doNotOptimizeAway(queue.move());
  }
}

void runPushBenchmark	(	int64_t	iters,
		const std::string &	str
	)

Definition at line 53 of file QueueAppenderBenchmark.cpp.

References folly::doNotOptimizeAway(), i, kBenchmarkSize, folly::IOBufQueue::move(), and folly::io::detail::Writable< Derived >::push().

Referenced by BENCHMARK().

                                                           {
  constexpr size_t kNumPushPerIter = 1024;
  while (iters--) {
    folly::IOBufQueue queue;
    QueueAppender appender(&queue, kBenchmarkSize);
    for (size_t i = 0; i < kNumPushPerIter; ++i) {
      appender.push(reinterpret_cast<const uint8_t*>(str.data()), str.size());
    }
    folly::doNotOptimizeAway(queue.move());
  }
}

Variable Documentation

constexpr size_t kBenchmarkSize = 4096

Definition at line 27 of file QueueAppenderBenchmark.cpp.

Referenced by BENCHMARK(), preallocate_postallocate_bench(), runArithmeticBench(), and runPushBenchmark().