Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
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.
262 lines
6.5 KiB
262 lines
6.5 KiB
#include <algorithm> |
|
#include <cstdint> |
|
#include <memory> |
|
#include <vector> |
|
|
|
#include <benchmark/benchmark.h> |
|
#include "absl/log/absl_check.h" |
|
#include "google/protobuf/hpb/arena.h" |
|
#include "google/protobuf/hpb/hpb.h" |
|
#include "google/protobuf/repeated_ptr_field.h" |
|
#include "google/protobuf/rust/test/benchmarks/bench_data.pb.h" |
|
#include "google/protobuf/rust/test/benchmarks/bench_data.upb.proto.h" |
|
|
|
using benchmarks::BenchData; |
|
|
|
#ifdef BENCHMARK_UPB |
|
#define PROTO_BENCHMARK(NAME) EXTERN_BENCHMARK(NAME##_upb); |
|
#else |
|
#define PROTO_BENCHMARK(NAME) EXTERN_BENCHMARK(NAME##_cpp); |
|
#endif |
|
|
|
#define EXTERN_BENCHMARK(NAME) \ |
|
extern "C" { \ |
|
void NAME##_bench(); \ |
|
} \ |
|
void BM_##NAME(benchmark::State& state) { \ |
|
for (auto s : state) { \ |
|
NAME##_bench(); \ |
|
} \ |
|
} \ |
|
BENCHMARK(BM_##NAME); |
|
|
|
void BM_set_string_cpp(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
data->set_name( |
|
"a relatively long string that will avoid any short string " |
|
"optimizations."); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_set_string_cpp); |
|
|
|
PROTO_BENCHMARK(set_string_rs); |
|
|
|
void BM_set_int_cpp(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
data->set_num2(123456789); |
|
ABSL_CHECK_EQ(data->num2(), 123456789); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_set_int_cpp); |
|
|
|
PROTO_BENCHMARK(set_int_rs); |
|
|
|
extern "C" { |
|
void benchmark_thunk_set_num2_rs(void* data, int32_t num2); |
|
} |
|
|
|
void BM_set_int_cpp_roundtrip(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
benchmark_thunk_set_num2_rs((void*)data.get(), 123456789); |
|
ABSL_CHECK_EQ(data->num2(), 123456789); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_set_int_cpp_roundtrip); |
|
|
|
void BM_add_10_repeated_msg_copy_cpp(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 10; ++i) { |
|
auto sub_data = std::make_unique<BenchData>(); |
|
sub_data->set_num2(i); |
|
*data->add_subs() = *sub_data; |
|
} |
|
} |
|
} |
|
|
|
BENCHMARK(BM_add_10_repeated_msg_copy_cpp); |
|
|
|
PROTO_BENCHMARK(add_10_repeated_msg_rs); |
|
|
|
void BM_add_10_repeated_msg_direct_cpp(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 10; ++i) { |
|
auto sub_data = data->add_subs(); |
|
sub_data->set_num2(i); |
|
} |
|
} |
|
} |
|
|
|
BENCHMARK(BM_add_10_repeated_msg_direct_cpp); |
|
|
|
void BM_copy_from_10_repeated_msg_cpp(benchmark::State& state) { |
|
auto source = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 10; ++i) { |
|
auto sub_data = source->add_subs(); |
|
sub_data->set_num2(i); |
|
} |
|
for (auto s : state) { |
|
benchmarks::BenchData data; |
|
*data.mutable_subs() = source->subs(); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_copy_from_10_repeated_msg_cpp); |
|
|
|
void BM_back_inserter_from_10_repeated_msg_cpp(benchmark::State& state) { |
|
auto source = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 10; ++i) { |
|
auto sub_data = source->add_subs(); |
|
sub_data->set_num2(i); |
|
} |
|
for (auto s : state) { |
|
benchmarks::BenchData data; |
|
std::copy(source->subs().begin(), source->subs().end(), |
|
google::protobuf::RepeatedFieldBackInserter(data.mutable_subs())); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_back_inserter_from_10_repeated_msg_cpp); |
|
|
|
PROTO_BENCHMARK(copy_from_10_repeated_msg_rs); |
|
|
|
PROTO_BENCHMARK(extend_10_repeated_msg_rs); |
|
|
|
void BM_add_100_ints_cpp(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 100; ++i) { |
|
data->mutable_nums()->Add(i); |
|
} |
|
} |
|
} |
|
|
|
BENCHMARK(BM_add_100_ints_cpp); |
|
|
|
void BM_add_100_ints_upb(benchmark::State& state) { |
|
for (auto s : state) { |
|
hpb::Arena arena; |
|
auto data = ::hpb::CreateMessage<benchmarks::protos::BenchData>(arena); |
|
for (int i = 0; i < 100; ++i) { |
|
data.add_nums(i); |
|
} |
|
} |
|
} |
|
|
|
BENCHMARK(BM_add_100_ints_upb); |
|
|
|
PROTO_BENCHMARK(add_100_ints_rs); |
|
|
|
extern "C" { |
|
void benchmark_thunk_add_num_rs(void* data, int32_t num); |
|
} |
|
|
|
void BM_add_100_ints_rs_roundtrip(benchmark::State& state) { |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 100; ++i) { |
|
benchmark_thunk_add_num_rs((void*)data.get(), i); |
|
} |
|
} |
|
} |
|
|
|
BENCHMARK(BM_add_100_ints_rs_roundtrip); |
|
|
|
void BM_copy_from_100_ints_cpp(benchmark::State& state) { |
|
auto source = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 100; ++i) { |
|
source->add_nums(i); |
|
} |
|
for (auto s : state) { |
|
auto data = std::make_unique<BenchData>(); |
|
*data->mutable_nums() = source->nums(); |
|
ABSL_CHECK_EQ(data->nums()[99], 99); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_copy_from_100_ints_cpp); |
|
|
|
void BM_copy_from_100_ints_upb(benchmark::State& state) { |
|
hpb::Arena arena; |
|
auto source = ::hpb::CreateMessage<benchmarks::protos::BenchData>(arena); |
|
for (int i = 0; i < 100; ++i) { |
|
source.add_nums(i); |
|
} |
|
for (auto s : state) { |
|
auto data = ::hpb::CreateMessage<benchmarks::protos::BenchData>(arena); |
|
data.resize_nums(source.nums_size()); |
|
std::copy(source.nums().begin(), source.nums().end(), |
|
data.mutable_nums()->begin()); |
|
ABSL_CHECK_EQ(data.nums()[99], 99); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_copy_from_100_ints_upb); |
|
|
|
PROTO_BENCHMARK(copy_from_100_ints_rs); |
|
|
|
PROTO_BENCHMARK(extend_100_ints_rs); |
|
|
|
EXTERN_BENCHMARK(extend_100_ints_vec_rs); |
|
|
|
PROTO_BENCHMARK(sum_1000_ints_rs); |
|
|
|
EXTERN_BENCHMARK(sum_1000_ints_vec_rs); |
|
|
|
void BM_sum_1000_ints_cpp(benchmark::State& state) { |
|
auto source = std::make_unique<BenchData>(); |
|
for (int i = 0; i < 1000; ++i) { |
|
source->add_nums(i); |
|
} |
|
|
|
for (auto s : state) { |
|
int sum = 0; |
|
for (auto x : source->nums()) { |
|
sum += x; |
|
} |
|
ABSL_CHECK_EQ(sum, 499500); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_sum_1000_ints_cpp); |
|
|
|
void BM_sum_1000_ints_upb(benchmark::State& state) { |
|
hpb::Arena arena; |
|
auto data = ::hpb::CreateMessage<benchmarks::protos::BenchData>(arena); |
|
for (int i = 0; i < 1000; ++i) { |
|
data.add_nums(i); |
|
} |
|
for (auto s : state) { |
|
int sum = 0; |
|
for (auto x : data.nums()) { |
|
sum += x; |
|
} |
|
ABSL_CHECK_EQ(sum, 499500); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_sum_1000_ints_upb); |
|
|
|
void BM_sum_1000_ints_vector(benchmark::State& state) { |
|
std::vector<int32_t> nums; |
|
nums.reserve(1000); |
|
for (int i = 0; i < 1000; ++i) { |
|
nums.push_back(i); |
|
} |
|
for (auto s : state) { |
|
int sum = 0; |
|
for (auto x : nums) { |
|
sum += x; |
|
} |
|
ABSL_CHECK_EQ(sum, 499500); |
|
} |
|
} |
|
|
|
BENCHMARK(BM_sum_1000_ints_vector);
|
|
|