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.
282 lines
9.4 KiB
282 lines
9.4 KiB
// Copyright (c) 2009-2021, Google LLC |
|
// All rights reserved. |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are met: |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * Redistributions in binary form must reproduce the above copyright |
|
// notice, this list of conditions and the following disclaimer in the |
|
// documentation and/or other materials provided with the distribution. |
|
// * Neither the name of Google LLC nor the |
|
// names of its contributors may be used to endorse or promote products |
|
// derived from this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
// DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY |
|
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
#include <benchmark/benchmark.h> |
|
#include <string.h> |
|
|
|
#include "absl/container/flat_hash_set.h" |
|
#include "benchmarks/descriptor.pb.h" |
|
#include "benchmarks/descriptor.upb.h" |
|
#include "benchmarks/descriptor.upbdefs.h" |
|
#include "benchmarks/descriptor_sv.pb.h" |
|
#include "google/ads/googleads/v7/services/google_ads_service.upbdefs.h" |
|
#include "google/protobuf/descriptor.pb.h" |
|
#include "upb/def.hpp" |
|
|
|
upb_strview descriptor = benchmarks_descriptor_proto_upbdefinit.descriptor; |
|
namespace protobuf = ::google::protobuf; |
|
|
|
/* A buffer big enough to parse descriptor.proto without going to heap. */ |
|
char buf[65535]; |
|
|
|
void CollectFileDescriptors(const upb_def_init* file, |
|
std::vector<upb_strview>& serialized_files, |
|
absl::flat_hash_set<const upb_def_init*>& seen) { |
|
if (!seen.insert(file).second) return; |
|
for (upb_def_init **deps = file->deps; *deps; deps++) { |
|
CollectFileDescriptors(*deps, serialized_files, seen); |
|
} |
|
serialized_files.push_back(file->descriptor); |
|
} |
|
|
|
static void BM_ArenaOneAlloc(benchmark::State& state) { |
|
for (auto _ : state) { |
|
upb_arena* arena = upb_arena_new(); |
|
upb_arena_malloc(arena, 1); |
|
upb_arena_free(arena); |
|
} |
|
} |
|
BENCHMARK(BM_ArenaOneAlloc); |
|
|
|
static void BM_ArenaInitialBlockOneAlloc(benchmark::State& state) { |
|
for (auto _ : state) { |
|
upb_arena* arena = upb_arena_init(buf, sizeof(buf), NULL); |
|
upb_arena_malloc(arena, 1); |
|
upb_arena_free(arena); |
|
} |
|
} |
|
BENCHMARK(BM_ArenaInitialBlockOneAlloc); |
|
|
|
static void BM_LoadDescriptor_Upb(benchmark::State& state) { |
|
size_t bytes_per_iter = 0; |
|
for (auto _ : state) { |
|
upb::SymbolTable symtab; |
|
upb_benchmark_DescriptorProto_getmsgdef(symtab.ptr()); |
|
bytes_per_iter = _upb_symtab_bytesloaded(symtab.ptr()); |
|
} |
|
state.SetBytesProcessed(state.iterations() * bytes_per_iter); |
|
} |
|
BENCHMARK(BM_LoadDescriptor_Upb); |
|
|
|
static void BM_LoadAdsDescriptor_Upb(benchmark::State& state) { |
|
size_t bytes_per_iter = 0; |
|
for (auto _ : state) { |
|
upb::SymbolTable symtab; |
|
google_ads_googleads_v7_services_SearchGoogleAdsRequest_getmsgdef( |
|
symtab.ptr()); |
|
bytes_per_iter = _upb_symtab_bytesloaded(symtab.ptr()); |
|
} |
|
state.SetBytesProcessed(state.iterations() * bytes_per_iter); |
|
} |
|
BENCHMARK(BM_LoadAdsDescriptor_Upb); |
|
|
|
static void BM_LoadDescriptor_Proto2(benchmark::State& state) { |
|
for (auto _ : state) { |
|
protobuf::Arena arena; |
|
protobuf::StringPiece input(descriptor.data,descriptor.size); |
|
auto proto = protobuf::Arena::CreateMessage<protobuf::FileDescriptorProto>( |
|
&arena); |
|
protobuf::DescriptorPool pool; |
|
bool ok = proto->ParseFrom<protobuf::MessageLite::kMergePartial>(input) && |
|
pool.BuildFile(*proto) != nullptr; |
|
if (!ok) { |
|
printf("Failed to add file.\n"); |
|
exit(1); |
|
} |
|
} |
|
state.SetBytesProcessed(state.iterations() * descriptor.size); |
|
} |
|
BENCHMARK(BM_LoadDescriptor_Proto2); |
|
|
|
static void BM_LoadAdsDescriptor_Proto2(benchmark::State& state) { |
|
extern upb_def_init google_ads_googleads_v7_services_google_ads_service_proto_upbdefinit; |
|
std::vector<upb_strview> serialized_files; |
|
absl::flat_hash_set<const upb_def_init*> seen_files; |
|
CollectFileDescriptors( |
|
&google_ads_googleads_v7_services_google_ads_service_proto_upbdefinit, |
|
serialized_files, seen_files); |
|
size_t bytes_per_iter = 0; |
|
for (auto _ : state) { |
|
bytes_per_iter = 0; |
|
protobuf::Arena arena; |
|
protobuf::DescriptorPool pool; |
|
for (auto file : serialized_files) { |
|
protobuf::StringPiece input(file.data, file.size); |
|
auto proto = protobuf::Arena::CreateMessage<protobuf::FileDescriptorProto>( |
|
&arena); |
|
bool ok = proto->ParseFrom<protobuf::MessageLite::kMergePartial>(input) && |
|
pool.BuildFile(*proto) != nullptr; |
|
if (!ok) { |
|
printf("Failed to add file.\n"); |
|
exit(1); |
|
} |
|
bytes_per_iter += input.size(); |
|
} |
|
} |
|
state.SetBytesProcessed(state.iterations() * bytes_per_iter); |
|
} |
|
BENCHMARK(BM_LoadAdsDescriptor_Proto2); |
|
|
|
enum CopyStrings { |
|
Copy, |
|
Alias, |
|
}; |
|
|
|
enum ArenaMode { |
|
NoArena, |
|
UseArena, |
|
InitBlock, |
|
}; |
|
|
|
template <ArenaMode AMode, CopyStrings Copy> |
|
static void BM_Parse_Upb_FileDesc(benchmark::State& state) { |
|
size_t bytes = 0; |
|
for (auto _ : state) { |
|
upb_arena *arena; |
|
if (AMode == InitBlock) { |
|
arena = upb_arena_init(buf, sizeof(buf), NULL); |
|
} else { |
|
arena = upb_arena_new(); |
|
} |
|
upb_benchmark_FileDescriptorProto* set = |
|
upb_benchmark_FileDescriptorProto_parse_ex( |
|
descriptor.data, descriptor.size, NULL, |
|
Copy == Alias ? kUpb_DecodeOption_AliasString : 0, arena); |
|
if (!set) { |
|
printf("Failed to parse.\n"); |
|
exit(1); |
|
} |
|
bytes += descriptor.size; |
|
upb_arena_free(arena); |
|
} |
|
state.SetBytesProcessed(state.iterations() * descriptor.size); |
|
} |
|
BENCHMARK_TEMPLATE(BM_Parse_Upb_FileDesc, UseArena, Copy); |
|
BENCHMARK_TEMPLATE(BM_Parse_Upb_FileDesc, UseArena, Alias); |
|
BENCHMARK_TEMPLATE(BM_Parse_Upb_FileDesc, InitBlock, Copy); |
|
BENCHMARK_TEMPLATE(BM_Parse_Upb_FileDesc, InitBlock, Alias); |
|
|
|
template <ArenaMode AMode, class P> |
|
struct Proto2Factory; |
|
|
|
template<class P> |
|
struct Proto2Factory<NoArena, P> { |
|
public: |
|
P* GetProto() { return &proto_; } |
|
|
|
private: |
|
P proto_; |
|
}; |
|
|
|
template <class P> |
|
struct Proto2Factory<UseArena, P> { |
|
public: |
|
P* GetProto() { return protobuf::Arena::CreateMessage<P>(&arena_); } |
|
|
|
private: |
|
protobuf::Arena arena_; |
|
}; |
|
|
|
template <class P> |
|
struct Proto2Factory<InitBlock, P> { |
|
public: |
|
Proto2Factory() : arena_(GetOptions()) {} |
|
P* GetProto() { return protobuf::Arena::CreateMessage<P>(&arena_); } |
|
|
|
private: |
|
protobuf::ArenaOptions GetOptions() { |
|
protobuf::ArenaOptions opts; |
|
opts.initial_block = buf; |
|
opts.initial_block_size = sizeof(buf); |
|
return opts; |
|
} |
|
|
|
protobuf::Arena arena_; |
|
}; |
|
|
|
using FileDesc = ::upb_benchmark::FileDescriptorProto; |
|
using FileDescSV = ::upb_benchmark::sv::FileDescriptorProto; |
|
|
|
template <class P, ArenaMode AMode, CopyStrings kCopy> |
|
void BM_Parse_Proto2(benchmark::State& state) { |
|
size_t bytes = 0; |
|
constexpr protobuf::MessageLite::ParseFlags kParseFlags = |
|
kCopy == Copy |
|
? protobuf::MessageLite::ParseFlags::kMergePartial |
|
: protobuf::MessageLite::ParseFlags::kMergePartialWithAliasing; |
|
for (auto _ : state) { |
|
Proto2Factory<AMode, P> proto_factory; |
|
auto proto = proto_factory.GetProto(); |
|
protobuf::StringPiece input(descriptor.data,descriptor.size); |
|
bool ok = proto->template ParseFrom<kParseFlags>(input); |
|
if (!ok) { |
|
printf("Failed to parse.\n"); |
|
exit(1); |
|
} |
|
bytes += descriptor.size; |
|
} |
|
state.SetBytesProcessed(state.iterations() * descriptor.size); |
|
} |
|
BENCHMARK_TEMPLATE(BM_Parse_Proto2, FileDesc, NoArena, Copy); |
|
BENCHMARK_TEMPLATE(BM_Parse_Proto2, FileDesc, UseArena, Copy); |
|
BENCHMARK_TEMPLATE(BM_Parse_Proto2, FileDesc, InitBlock, Copy); |
|
BENCHMARK_TEMPLATE(BM_Parse_Proto2, FileDescSV, InitBlock, Alias); |
|
|
|
static void BM_SerializeDescriptor_Proto2(benchmark::State& state) { |
|
size_t bytes = 0; |
|
upb_benchmark::FileDescriptorProto proto; |
|
proto.ParseFromArray(descriptor.data, descriptor.size); |
|
for (auto _ : state) { |
|
proto.SerializePartialToArray(buf, sizeof(buf)); |
|
bytes += descriptor.size; |
|
} |
|
state.SetBytesProcessed(state.iterations() * descriptor.size); |
|
} |
|
BENCHMARK(BM_SerializeDescriptor_Proto2); |
|
|
|
static void BM_SerializeDescriptor_Upb(benchmark::State& state) { |
|
int64_t total = 0; |
|
upb_arena* arena = upb_arena_new(); |
|
upb_benchmark_FileDescriptorProto* set = |
|
upb_benchmark_FileDescriptorProto_parse(descriptor.data, descriptor.size, |
|
arena); |
|
if (!set) { |
|
printf("Failed to parse.\n"); |
|
exit(1); |
|
} |
|
for (auto _ : state) { |
|
upb_arena* enc_arena = upb_arena_init(buf, sizeof(buf), NULL); |
|
size_t size; |
|
char* data = |
|
upb_benchmark_FileDescriptorProto_serialize(set, enc_arena, &size); |
|
if (!data) { |
|
printf("Failed to serialize.\n"); |
|
exit(1); |
|
} |
|
total += size; |
|
} |
|
state.SetBytesProcessed(total); |
|
} |
|
BENCHMARK(BM_SerializeDescriptor_Upb);
|
|
|