The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

100 lines
3.4 KiB

// Copyright 2022 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <cstdint>
#include <random>
#include <benchmark/benchmark.h>
#include "absl/strings/escaping.h"
#include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
#include "src/core/ext/transport/chttp2/transport/decode_huff.h"
#include "src/core/lib/slice/slice.h"
#include "src/core/util/no_destruct.h"
#include "test/core/test_util/test_config.h"
#include "test/cpp/microbenchmarks/huffman_geometries/index.h"
std::vector<uint8_t> MakeInput(int min, int max) {
std::vector<uint8_t> v;
std::uniform_int_distribution<> distribution(min, max);
static std::mt19937 rd(0);
v.reserve(1024 * 1024);
for (int i = 0; i < 1024 * 1024; i++) {
v.push_back(distribution(rd));
}
grpc_core::Slice s = grpc_core::Slice::FromCopiedBuffer(v);
grpc_core::Slice c(grpc_chttp2_huffman_compress(s.c_slice()));
return std::vector<uint8_t>(c.begin(), c.end());
}
std::vector<uint8_t> MakeBase64() {
auto src = MakeInput(0, 255);
auto s = absl::Base64Escape(
absl::string_view(reinterpret_cast<char*>(src.data()), src.size()));
return std::vector<uint8_t>(s.begin(), s.end());
}
const std::vector<uint8_t>& AllChars() {
static const auto* const data = new std::vector<uint8_t>(MakeInput(0, 255));
return *data;
};
const std::vector<uint8_t>& AsciiChars() {
static const auto* const data = new std::vector<uint8_t>(MakeInput(32, 126));
return *data;
};
const std::vector<uint8_t>& AlphaChars() {
static const auto* const data = new std::vector<uint8_t>(MakeInput('a', 'z'));
return *data;
};
const std::vector<uint8_t>& Base64Chars() {
static const auto* const data = new std::vector<uint8_t>(MakeBase64());
return *data;
};
using CharSet = const std::vector<uint8_t>& (*)();
template <template <typename Sink> class Decoder>
static void BM_Decode(benchmark::State& state, CharSet chars_gen) {
const std::vector<uint8_t>& chars = chars_gen();
std::vector<uint8_t> output;
auto add = [&output](uint8_t c) { output.push_back(c); };
for (auto _ : state) {
output.clear();
Decoder<decltype(add)>(add, chars.data(), chars.data() + chars.size())
.Run();
}
}
#define DECL_BENCHMARK(cls, name) \
static auto name = BM_Decode<cls>; \
BENCHMARK_CAPTURE(name, all_chars, AllChars); \
BENCHMARK_CAPTURE(name, base64_chars, Base64Chars); \
BENCHMARK_CAPTURE(name, ascii_chars, AsciiChars); \
BENCHMARK_CAPTURE(name, alpha_chars, AlphaChars)
DECL_HUFFMAN_VARIANTS();
// Some distros have RunSpecifiedBenchmarks under the benchmark namespace,
// and others do not. This allows us to support both modes.
namespace benchmark {
void RunTheBenchmarksNamespaced() { RunSpecifiedBenchmarks(); }
} // namespace benchmark
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
benchmark::Initialize(&argc, argv);
benchmark::RunTheBenchmarksNamespaced();
return 0;
}