FormatBenchmark.cpp File Reference

#include <folly/Format.h>
#include <glog/logging.h>
#include <folly/Benchmark.h>
#include <folly/FBVector.h>
#include <folly/Utility.h>
#include <folly/dynamic.h>
#include <folly/init/Init.h>
#include <folly/json.h>

Go to the source code of this file.

Functions
	BENCHMARK (octal_snprintf, iters)
	BENCHMARK_RELATIVE (octal_uintToOctal, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (hex_snprintf, iters)
	BENCHMARK_RELATIVE (hex_uintToHex, iters)
	BENCHMARK (intAppend_snprintf)
	BENCHMARK_RELATIVE (intAppend_to)
	BENCHMARK_RELATIVE (intAppend_format)
template<size_t... Indexes>
int	snprintf20Numbers (int i, index_sequence< Indexes... >)
	BENCHMARK (bigFormat_snprintf, iters)
template<size_t... Indexes>
decltype(auto)	format20Numbers (int i, index_sequence< Indexes... >)
	BENCHMARK_RELATIVE (bigFormat_format, iters)
	BENCHMARK (format_nested_strings, iters)
	BENCHMARK_RELATIVE (format_nested_fbstrings, iters)
	BENCHMARK_RELATIVE (format_nested_direct, iters)
	BENCHMARK (copy_short_string, iters)
	BENCHMARK_RELATIVE (format_short_string_unsafe, iters)
	BENCHMARK_RELATIVE (format_short_string_safe, iters)
	BENCHMARK_RELATIVE (sformat_short_string_unsafe, iters)
	BENCHMARK_RELATIVE (sformat_short_string_safe, iters)
	BENCHMARK (copy_long_string, iters)
	BENCHMARK_RELATIVE (format_long_string_unsafe, iters)
	BENCHMARK_RELATIVE (format_long_string_safe, iters)
	BENCHMARK_RELATIVE (sformat_long_string_unsafe, iters)
	BENCHMARK_RELATIVE (sformat_long_string_safe, iters)
int	main (int argc, char *argv[])

Function Documentation

BENCHMARK	(	octal_snprintf	,
		iters
	)

Definition at line 44 of file FormatBenchmark.cpp.

                                 {
  while (iters--) {
    snprintf(
        bigBuf.data(), bigBuf.size(), "%o", static_cast<unsigned int>(iters));
  }
}

BENCHMARK	(	hex_snprintf	,
		iters
	)

Definition at line 62 of file FormatBenchmark.cpp.

                               {
  while (iters--) {
    snprintf(
        bigBuf.data(), bigBuf.size(), "%x", static_cast<unsigned int>(iters));
  }
}

BENCHMARK

(

intAppend_snprintf

)

Definition at line 78 of file FormatBenchmark.cpp.

References folly::basic_fbstring< E, T, A, Storage >::append(), and i.

                              {
  fbstring out;
  for (int i = -1000; i < 1000; i++) {
    snprintf(bigBuf.data(), bigBuf.size(), "%d", i);
    out.append(bigBuf.data());
  }
}

BENCHMARK	(	bigFormat_snprintf	,
		iters
	)

Definition at line 115 of file FormatBenchmark.cpp.

References i, and snprintf20Numbers().

                                     {
  while (iters--) {
    for (int i = -100; i < 100; i++) {
      snprintf20Numbers(i, make_index_sequence<20>());
    }
  }
}

BENCHMARK	(	format_nested_strings	,
		iters
	)

Definition at line 153 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::format(), and i.

                                        {
  BenchmarkSuspender suspender;
  while (iters--) {
    for (int i = 0; i < 1000; ++i) {
      fbstring out;
      suspender.dismissing([&] {
        format(
            &out,
            "{} {}",
            format("{} {}", i, i + 1).str(),
            format("{} {}", -i, -i - 1).str());
      });
    }
  }
}

BENCHMARK	(	copy_short_string	,
		iters
	)

Definition at line 203 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing().

                                    {
  BenchmarkSuspender suspender;
  auto const& shortString = getShortString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { out = shortString; });
  }
}

BENCHMARK	(	copy_long_string	,
		iters
	)

Definition at line 250 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing().

                                   {
  BenchmarkSuspender suspender;
  auto const& longString = getLongString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { out = longString; });
  }
}

BENCHMARK_DRAW_LINE

(

)

BENCHMARK_RELATIVE	(	octal_uintToOctal	,
		iters
	)

Definition at line 51 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::detail::kMaxOctalLength, and folly::detail::uintToOctal().

                                             {
  while (iters--) {
    detail::uintToOctal(
        bigBuf.data(),
        detail::kMaxOctalLength,
        static_cast<unsigned int>(iters));
  }
}

BENCHMARK_RELATIVE	(	hex_uintToHex	,
		iters
	)

Definition at line 69 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::detail::kMaxHexLength, and folly::detail::uintToHexLower().

                                         {
  while (iters--) {
    detail::uintToHexLower(
        bigBuf.data(), detail::kMaxHexLength, static_cast<unsigned int>(iters));
  }
}

BENCHMARK_RELATIVE

(

intAppend_to

)

Definition at line 86 of file FormatBenchmark.cpp.

References i, and folly::toAppend().

                                 {
  fbstring out;
  for (int i = -1000; i < 1000; i++) {
    toAppend(i, &out);
  }
}

BENCHMARK_RELATIVE

(

intAppend_format

)

Definition at line 93 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::format(), and i.

                                     {
  fbstring out;
  for (int i = -1000; i < 1000; i++) {
    format(&out, "{}", i);
  }
}

BENCHMARK_RELATIVE	(	bigFormat_format	,
		iters
	)

Definition at line 134 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::BenchmarkSuspender::dismissing(), format20Numbers(), and i.

                                            {
  BenchmarkSuspender suspender;
  char* p;
  auto writeToBuf = [&p](StringPiece sp) mutable {
    memcpy(p, sp.data(), sp.size());
    p += sp.size();
  };

  while (iters--) {
    for (int i = -100; i < 100; i++) {
      p = bigBuf.data();
      suspender.dismissing(
          [&] { format20Numbers(i, make_index_sequence<20>())(writeToBuf); });
    }
  }
}

BENCHMARK_RELATIVE	(	format_nested_fbstrings	,
		iters
	)

Definition at line 169 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::format(), and i.

                                                   {
  BenchmarkSuspender suspender;
  while (iters--) {
    for (int i = 0; i < 1000; ++i) {
      fbstring out;
      suspender.dismissing([&] {
        format(
            &out,
            "{} {}",
            format("{} {}", i, i + 1).fbstr(),
            format("{} {}", -i, -i - 1).fbstr());
      });
    }
  }
}

BENCHMARK_RELATIVE	(	format_nested_direct	,
		iters
	)

Definition at line 185 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::BenchmarkSuspender::dismissing(), folly::format(), and i.

                                                {
  BenchmarkSuspender suspender;
  while (iters--) {
    for (int i = 0; i < 1000; ++i) {
      fbstring out;
      suspender.dismissing([&] {
        format(
            &out,
            "{} {}",
            format("{} {}", i, i + 1),
            format("{} {}", -i, -i - 1));
      });
    }
  }
}

BENCHMARK_RELATIVE	(	format_short_string_unsafe	,
		iters
	)

Definition at line 212 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), and folly::format().

                                                      {
  BenchmarkSuspender suspender;
  auto const& shortString = getShortString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { format(&out, shortString); });
  }
}

BENCHMARK_RELATIVE	(	format_short_string_safe	,
		iters
	)

Definition at line 221 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), and folly::format().

                                                    {
  BenchmarkSuspender suspender;
  auto const& shortString = getShortString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { format(&out, "{}", shortString); });
  }
}

BENCHMARK_RELATIVE	(	sformat_short_string_unsafe	,
		iters
	)

Definition at line 230 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::sformat(), and string.

                                                       {
  BenchmarkSuspender suspender;
  auto const& shortString = getShortString();
  while (iters--) {
    std::string out;
    suspender.dismissing([&] { out = sformat(shortString); });
  }
}

BENCHMARK_RELATIVE	(	sformat_short_string_safe	,
		iters
	)

Definition at line 239 of file FormatBenchmark.cpp.

References folly::BENCHMARK_DRAW_LINE(), folly::BenchmarkSuspender::dismissing(), folly::sformat(), and string.

                                                     {
  BenchmarkSuspender suspender;
  auto const& shortString = getShortString();
  while (iters--) {
    std::string out;
    suspender.dismissing([&] { out = sformat("{}", shortString); });
  }
}

BENCHMARK_RELATIVE	(	format_long_string_unsafe	,
		iters
	)

Definition at line 259 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), and folly::format().

                                                     {
  BenchmarkSuspender suspender;
  auto const& longString = getLongString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { format(&out, longString); });
  }
}

BENCHMARK_RELATIVE	(	format_long_string_safe	,
		iters
	)

Definition at line 268 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), and folly::format().

                                                   {
  BenchmarkSuspender suspender;
  auto const& longString = getLongString();
  while (iters--) {
    fbstring out;
    suspender.dismissing([&] { format(&out, "{}", longString); });
  }
}

BENCHMARK_RELATIVE	(	sformat_long_string_unsafe	,
		iters
	)

Definition at line 277 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::sformat(), and string.

                                                      {
  BenchmarkSuspender suspender;
  auto const& longString = getLongString();
  while (iters--) {
    std::string out;
    suspender.dismissing([&] { out = sformat(longString); });
  }
}

BENCHMARK_RELATIVE	(	sformat_long_string_safe	,
		iters
	)

Definition at line 286 of file FormatBenchmark.cpp.

References folly::BenchmarkSuspender::dismissing(), folly::sformat(), and string.

                                                    {
  BenchmarkSuspender suspender;
  auto const& longString = getLongString();
  while (iters--) {
    std::string out;
    suspender.dismissing([&] { out = sformat("{}", longString); });
  }
}

template<size_t... Indexes>

decltype(auto) format20Numbers	(	int	i,
		index_sequence< Indexes... >
	)

Definition at line 124 of file FormatBenchmark.cpp.

References folly::format().

Referenced by BENCHMARK_RELATIVE().

                                                                  {
  static_assert(20 == sizeof...(Indexes), "Must have exactly 20 indexes");
  return format(
      "{} {} {} {} {}"
      "{} {} {} {} {}"
      "{} {} {} {} {}"
      "{} {} {} {} {}",
      (i + static_cast<int>(Indexes))...);
}

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

Definition at line 330 of file FormatBenchmark.cpp.

References folly::init(), and folly::runBenchmarks().

                                 {
  init(&argc, &argv, true);
  runBenchmarks();
  return 0;
}

template<size_t... Indexes>

int snprintf20Numbers	(	int	i,
		index_sequence< Indexes... >
	)

Definition at line 103 of file FormatBenchmark.cpp.

Referenced by BENCHMARK().

                                                         {
  static_assert(20 == sizeof...(Indexes), "Must have exactly 20 indexes");
  return snprintf(
      bigBuf.data(),
      bigBuf.size(),
      "%d %d %d %d %d"
      "%d %d %d %d %d"
      "%d %d %d %d %d"
      "%d %d %d %d %d",
      (i + static_cast<int>(Indexes))...);
}