19 #include <boost/algorithm/string.hpp> 24 using namespace folly;
28 static const size_t kSize = 256;
35 static char input[kSize];
36 for (
size_t i = 0;
i < kSize;
i++) {
37 input[
i] = (char)(
i & 0xff);
39 for (
auto i = iters;
i > 0;
i--) {
40 for (
size_t offset = 0; offset < kSize; offset++) {
41 input[offset] = tolower(input[offset]);
47 static const size_t kSize = 256;
48 static char input[kSize];
49 for (
size_t i = 0;
i < kSize;
i++) {
50 input[
i] = (char)(
i & 0xff);
52 for (
auto i = iters;
i > 0;
i--) {
62 buffer.resize(param,
'x');
66 string s =
stringPrintf(
"msg: %d, %d, %s", 10, 20, buffer.c_str());
83 for (
unsigned int i = 0;
i < iters; ++
i) {
88 for (
int j = 0; j < 300000; ++j) {
99 const size_t kCBmStringLength = 64 << 10;
100 const uint32_t kCPrintablePercentage = 90;
106 const size_t kURIBmStringLength = 256;
107 const uint32_t kURIPassThroughPercentage = 50;
111 const size_t kHexlifyLength = 1024;
113 void initBenchmark() {
117 std::uniform_int_distribution<uint32_t> printable(32, 126);
118 std::uniform_int_distribution<uint32_t> nonPrintable(0, 160);
119 std::uniform_int_distribution<uint32_t> percentage(0, 99);
121 cbmString.
reserve(kCBmStringLength);
122 for (
size_t i = 0;
i < kCBmStringLength; ++
i) {
124 if (percentage(rnd) < kCPrintablePercentage) {
127 c = nonPrintable(rnd);
137 cbmEscapedString = cEscape<fbstring>(cbmString);
140 std::uniform_int_distribution<uint32_t>
passthrough(
'a',
'z');
142 std::uniform_int_distribution<uint32_t>
encode(0, encodeChars.size() - 1);
144 uribmString.
reserve(kURIBmStringLength);
145 for (
size_t i = 0;
i < kURIBmStringLength; ++
i) {
147 if (percentage(rnd) < kURIPassThroughPercentage) {
150 c = encodeChars[
encode(rnd)];
155 uribmEscapedString = uriEscape<fbstring>(uribmString);
158 hexlifyInput.
resize(kHexlifyLength);
165 cEscapedString = cEscape<fbstring>(cbmString);
172 cUnescapedString = cUnescape<fbstring>(cbmEscapedString);
179 uriEscapedString = uriEscape<fbstring>(uribmString);
186 uriUnescapedString = uriUnescape<fbstring>(uribmEscapedString);
195 for (; iters >= hex.
size(); iters -= hex.
size()) {
208 static const std::string line =
"one:two:three:four";
209 for (
size_t i = 0;
i < iters << 4; ++
i) {
210 std::vector<StringPiece> pieces;
216 static const std::string line =
"one:two:three:four";
217 for (
size_t i = 0;
i < iters << 4; ++
i) {
224 static const std::string line =
"one:two:three:four";
225 for (
size_t i = 0;
i < iters << 4; ++
i) {
227 folly::split<false>(
':', line,
a,
b,
c, d);
232 static const std::string line =
"one-*-two-*-three-*-four";
233 for (
size_t i = 0;
i < iters << 4; ++
i) {
234 std::vector<StringPiece> pieces;
240 static const std::string line =
"one-*-two-*-three-*-four";
241 for (
size_t i = 0;
i < iters << 4; ++
i) {
248 static const std::string line =
"one:two:three:four";
249 bool (*pred)(char) = [](
char c) ->
bool {
return c ==
':'; };
250 for (
size_t i = 0;
i < iters << 4; ++
i) {
251 std::vector<boost::iterator_range<std::string::const_iterator>> pieces;
257 static const std::vector<std::string> input = {
258 "one",
"two",
"three",
"four",
"five",
"six",
"seven"};
259 for (
size_t i = 0;
i < iters << 4; ++
i) {
266 static const std::vector<std::string> input = {
267 "one",
"two",
"three",
"four",
"five",
"six",
"seven"};
268 for (
size_t i = 0;
i < iters << 4; ++
i) {
275 static const auto input = {123, 456, 78910, 1112, 1314, 151, 61718};
276 for (
size_t i = 0;
i < iters << 4; ++
i) {
283 gflags::ParseCommandLineFlags(&argc, &argv,
true);
std::vector< uint8_t > buffer(kBufferSize+16)
bool unhexlify(const InputString &input, OutputString &output)
unique_ptr< IOBuf > encode(vector< HPACKHeader > &headers, HPACKEncoder &encoder)
static std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value, T >::type secureRandom()
#define BENCHMARK_SUSPEND
constexpr size_type size() const
std::string stringPrintf(const char *format,...)
—— Concurrent Priority Queue Implementation ——
void split(const Delim &delimiter, const String &input, std::vector< OutputType > &out, bool ignoreEmpty)
void reserve(size_type res_arg=0)
void stringPrintfOutputSize(int iters, int param)
Range subpiece(size_type first, size_type length=npos) const
S split(const StringPiece source, char delimiter)
Target passthrough(Target target)
void push_back(const value_type c)
std::string & stringAppendf(std::string *output, const char *format,...)
#define BENCHMARK_PARAM(name, param)
void toLowerAscii(char *str, size_t length)
BENCHMARK(fbFollyGlobalBenchmarkBaseline)
void join(const Delim &delimiter, Iterator begin, Iterator end, String &output)
bool hexlify(const InputString &input, OutputString &output, bool append_output)
int main(int argc, char *argv[])
void resize(size_type n, value_type c=value_type())
auto doNotOptimizeAway(const T &datum) -> typename std::enable_if< !detail::DoNotOptimizeAwayNeedsIndirect< T >::value >::type