test/cpp/microbenchmarks/bm_byte_buffer.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 /* This benchmark exists to show that byte-buffer copy is size-independent */
  20
  21 #include <memory>
  22
  23 #include <benchmark/benchmark.h>
  24 #include <grpcpp/impl/grpc_library.h>
  25 #include <grpcpp/support/byte_buffer.h>
  26 #include "test/cpp/microbenchmarks/helpers.h"
  27 #include "test/cpp/util/test_config.h"
  28
  29 namespace grpc {
  30 namespace testing {
  31
  32 static void BM_ByteBuffer_Copy(benchmark::State& state) {
  33   Library::get();
  34   int num_slices = state.range(0);
  35   size_t slice_size = state.range(1);
  36   std::vector<grpc::Slice> slices;
  37   while (num_slices > 0) {
  38     num_slices--;
  39     std::unique_ptr<char[]> buf(new char[slice_size]);
  40     memset(buf.get(), 0, slice_size);
  41     slices.emplace_back(buf.get(), slice_size);
  42   }
  43   grpc::ByteBuffer bb(slices.data(), num_slices);
  44   while (state.KeepRunning()) {
  45     grpc::ByteBuffer cc(bb);
  46   }
  47 }
  48 BENCHMARK(BM_ByteBuffer_Copy)->Ranges({{1, 64}, {1, 1024 * 1024}});
  49
  50 static void BM_ByteBufferReader_Next(benchmark::State& state) {
  51   Library::get();
  52   const int num_slices = state.range(0);
  53   constexpr size_t kSliceSize = 16;
  54   std::vector<grpc_slice> slices;
  55   for (int i = 0; i < num_slices; ++i) {
  56     std::unique_ptr<char[]> buf(new char[kSliceSize]);
  57     slices.emplace_back(g_core_codegen_interface->grpc_slice_from_copied_buffer(
  58         buf.get(), kSliceSize));
  59   }
  60   grpc_byte_buffer* bb = g_core_codegen_interface->grpc_raw_byte_buffer_create(
  61       slices.data(), num_slices);
  62   grpc_byte_buffer_reader reader;
  63   GPR_ASSERT(
  64       g_core_codegen_interface->grpc_byte_buffer_reader_init(&reader, bb));
  65   while (state.KeepRunning()) {
  66     grpc_slice* slice;
  67     if (GPR_UNLIKELY(!g_core_codegen_interface->grpc_byte_buffer_reader_peek(
  68             &reader, &slice))) {
  69       g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader);
  70       GPR_ASSERT(
  71           g_core_codegen_interface->grpc_byte_buffer_reader_init(&reader, bb));
  72       continue;
  73     }
  74   }
  75
  76   g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader);
  77   g_core_codegen_interface->grpc_byte_buffer_destroy(bb);
  78   for (auto& slice : slices) {
  79     g_core_codegen_interface->grpc_slice_unref(slice);
  80   }
  81 }
  82 BENCHMARK(BM_ByteBufferReader_Next)->Ranges({{64 * 1024, 1024 * 1024}});
  83
  84 static void BM_ByteBufferReader_Peek(benchmark::State& state) {
  85   Library::get();
  86   const int num_slices = state.range(0);
  87   constexpr size_t kSliceSize = 16;
  88   std::vector<grpc_slice> slices;
  89   for (int i = 0; i < num_slices; ++i) {
  90     std::unique_ptr<char[]> buf(new char[kSliceSize]);
  91     slices.emplace_back(g_core_codegen_interface->grpc_slice_from_copied_buffer(
  92         buf.get(), kSliceSize));
  93   }
  94   grpc_byte_buffer* bb = g_core_codegen_interface->grpc_raw_byte_buffer_create(
  95       slices.data(), num_slices);
  96   grpc_byte_buffer_reader reader;
  97   GPR_ASSERT(
  98       g_core_codegen_interface->grpc_byte_buffer_reader_init(&reader, bb));
  99   while (state.KeepRunning()) {
 100     grpc_slice* slice;
 101     if (GPR_UNLIKELY(!g_core_codegen_interface->grpc_byte_buffer_reader_peek(
 102             &reader, &slice))) {
 103       g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader);
 104       GPR_ASSERT(
 105           g_core_codegen_interface->grpc_byte_buffer_reader_init(&reader, bb));
 106       continue;
 107     }
 108   }
 109
 110   g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader);
 111   g_core_codegen_interface->grpc_byte_buffer_destroy(bb);
 112   for (auto& slice : slices) {
 113     g_core_codegen_interface->grpc_slice_unref(slice);
 114   }
 115 }
 116 BENCHMARK(BM_ByteBufferReader_Peek)->Ranges({{64 * 1024, 1024 * 1024}});
 117
 118 }  // namespace testing
 119 }  // namespace grpc
 120
 121 // Some distros have RunSpecifiedBenchmarks under the benchmark namespace,
 122 // and others do not. This allows us to support both modes.
 123 namespace benchmark {
 124 void RunTheBenchmarksNamespaced() { RunSpecifiedBenchmarks(); }
 125 }  // namespace benchmark
 126
 127 int main(int argc, char** argv) {
 128   ::benchmark::Initialize(&argc, argv);
 129   ::grpc::testing::InitTest(&argc, &argv, false);
 130   benchmark::RunTheBenchmarksNamespaced();
 131   return 0;
 132 }