StringBenchmark.cpp File Reference

#include <folly/String.h>
#include <boost/algorithm/string.hpp>
#include <folly/Benchmark.h>
#include <folly/Random.h>
#include <random>

Go to the source code of this file.

Functions
	BENCHMARK (libc_tolower, iters)
	BENCHMARK (folly_toLowerAscii, iters)
void	stringPrintfOutputSize (int iters, int param)
	BENCHMARK (stringPrintfAppendfBenchmark, iters)
	BENCHMARK (splitOnSingleChar, iters)
	BENCHMARK (splitOnSingleCharFixed, iters)
	BENCHMARK (splitOnSingleCharFixedAllowExtra, iters)
	BENCHMARK (splitStr, iters)
	BENCHMARK (splitStrFixed, iters)
	BENCHMARK (boost_splitOnSingleChar, iters)
	BENCHMARK (joinCharStr, iters)
	BENCHMARK (joinStrStr, iters)
	BENCHMARK (joinInt, iters)
int	main (int argc, char **argv)

Function Documentation

BENCHMARK	(	libc_tolower	,
		iters
	)

Definition at line 27 of file StringBenchmark.cpp.

References i.

                               {
  static const size_t kSize = 256;
  // This array is static to keep the compiler from optimizing the
  // entire function down to a no-op if it has an inlined impl of
  // tolower and thus is able to tell that there are no side-effects.
  // No side-effects + no writes to anything other than local variables
  // + no return value = no need to run any of the code in the function.
  // gcc, for example, makes that optimization with -O2.
  static char input[kSize];
  for (size_t i = 0; i < kSize; i++) {
    input[i] = (char)(i & 0xff);
  }
  for (auto i = iters; i > 0; i--) {
    for (size_t offset = 0; offset < kSize; offset++) {
      input[offset] = tolower(input[offset]);
    }
  }
}

BENCHMARK	(	folly_toLowerAscii	,
		iters
	)

Definition at line 46 of file StringBenchmark.cpp.

References i, and folly::toLowerAscii().

                                     {
  static const size_t kSize = 256;
  static char input[kSize];
  for (size_t i = 0; i < kSize; i++) {
    input[i] = (char)(i & 0xff);
  }
  for (auto i = iters; i > 0; i--) {
    folly::toLowerAscii(input, kSize);
  }
}

BENCHMARK	(	stringPrintfAppendfBenchmark	,
		iters
	)

Definition at line 82 of file StringBenchmark.cpp.

References folly::BENCHMARK(), BENCHMARK_SUSPEND, c, folly::doNotOptimizeAway(), encode(), folly::hexlify(), i, folly::gen::detail::passthrough(), folly::basic_fbstring< E, T, A, Storage >::push_back(), folly::basic_fbstring< E, T, A, Storage >::reserve(), folly::basic_fbstring< E, T, A, Storage >::resize(), s, folly::Random::secureRandom(), folly::Range< Iter >::size(), folly::basic_fbstring< E, T, A, Storage >::size(), string, folly::stringAppendf(), folly::Range< Iter >::subpiece(), uint32_t, and folly::unhexlify().

                                               {
  for (unsigned int i = 0; i < iters; ++i) {
    string s;
    BENCHMARK_SUSPEND {
      s.reserve(300000);
    }
    for (int j = 0; j < 300000; ++j) {
      stringAppendf(&s, "%d", 1);
    }
  }
}

BENCHMARK	(	splitOnSingleChar	,
		iters
	)

Definition at line 207 of file StringBenchmark.cpp.

References i, folly::split(), and string.

                                    {
  static const std::string line = "one:two:three:four";
  for (size_t i = 0; i < iters << 4; ++i) {
    std::vector<StringPiece> pieces;
    folly::split(':', line, pieces);
  }
}

BENCHMARK	(	splitOnSingleCharFixed	,
		iters
	)

Definition at line 215 of file StringBenchmark.cpp.

References a, b, c, i, folly::split(), and string.

                                         {
  static const std::string line = "one:two:three:four";
  for (size_t i = 0; i < iters << 4; ++i) {
    StringPiece a, b, c, d;
    folly::split(':', line, a, b, c, d);
  }
}

BENCHMARK	(	splitOnSingleCharFixedAllowExtra	,
		iters
	)

Definition at line 223 of file StringBenchmark.cpp.

References a, b, c, i, and string.

                                                   {
  static const std::string line = "one:two:three:four";
  for (size_t i = 0; i < iters << 4; ++i) {
    StringPiece a, b, c, d;
    folly::split<false>(':', line, a, b, c, d);
  }
}

BENCHMARK	(	splitStr	,
		iters
	)

Definition at line 231 of file StringBenchmark.cpp.

References i, folly::split(), and string.

                           {
  static const std::string line = "one-*-two-*-three-*-four";
  for (size_t i = 0; i < iters << 4; ++i) {
    std::vector<StringPiece> pieces;
    folly::split("-*-", line, pieces);
  }
}

BENCHMARK	(	splitStrFixed	,
		iters
	)

Definition at line 239 of file StringBenchmark.cpp.

References a, b, c, i, folly::split(), and string.

                                {
  static const std::string line = "one-*-two-*-three-*-four";
  for (size_t i = 0; i < iters << 4; ++i) {
    StringPiece a, b, c, d;
    folly::split("-*-", line, a, b, c, d);
  }
}

BENCHMARK	(	boost_splitOnSingleChar	,
		iters
	)

Definition at line 247 of file StringBenchmark.cpp.

References c, i, folly::gen::split(), and string.

                                          {
  static const std::string line = "one:two:three:four";
  bool (*pred)(char) = [](char c) -> bool { return c == ':'; };
  for (size_t i = 0; i < iters << 4; ++i) {
    std::vector<boost::iterator_range<std::string::const_iterator>> pieces;
    boost::split(pieces, line, pred);
  }
}

BENCHMARK	(	joinCharStr	,
		iters
	)

Definition at line 256 of file StringBenchmark.cpp.

References i, folly::join(), gmock_output_test::output, and string.

                              {
  static const std::vector<std::string> input = {
      "one", "two", "three", "four", "five", "six", "seven"};
  for (size_t i = 0; i < iters << 4; ++i) {
    std::string output;
    folly::join(':', input, output);
  }
}

BENCHMARK	(	joinStrStr	,
		iters
	)

Definition at line 265 of file StringBenchmark.cpp.

References i, folly::join(), gmock_output_test::output, and string.

                             {
  static const std::vector<std::string> input = {
      "one", "two", "three", "four", "five", "six", "seven"};
  for (size_t i = 0; i < iters << 4; ++i) {
    std::string output;
    folly::join(":", input, output);
  }
}

BENCHMARK	(	joinInt	,
		iters
	)

Definition at line 274 of file StringBenchmark.cpp.

References i, folly::join(), gmock_output_test::output, and string.

                          {
  static const auto input = {123, 456, 78910, 1112, 1314, 151, 61718};
  for (size_t i = 0; i < iters << 4; ++i) {
    std::string output;
    folly::join(":", input, output);
  }
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 282 of file StringBenchmark.cpp.

References folly::runBenchmarks().

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

void stringPrintfOutputSize	(	int	iters,
		int	param
	)

Definition at line 59 of file StringBenchmark.cpp.

References BENCHMARK_PARAM, BENCHMARK_SUSPEND, buffer(), i, int64_t, s, and folly::stringPrintf().

                                                  {
  string buffer;
  BENCHMARK_SUSPEND {
    buffer.resize(param, 'x');
  }

  for (int64_t i = 0; i < iters; ++i) {
    string s = stringPrintf("msg: %d, %d, %s", 10, 20, buffer.c_str());
  }
}