grpc/test/cpp/microbenchmarks/callback_unary_ping_pong.h

/*
 *
 * Copyright 2019 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.
 *
 */

/* Benchmark gRPC end2end in various configurations */

#ifndef TEST_CPP_MICROBENCHMARKS_CALLBACK_UNARY_PING_PONG_H
#define TEST_CPP_MICROBENCHMARKS_CALLBACK_UNARY_PING_PONG_H

#include <benchmark/benchmark.h>
#include <sstream>
#include "src/core/lib/profiling/timers.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/cpp/microbenchmarks/callback_test_service.h"
#include "test/cpp/microbenchmarks/fullstack_context_mutators.h"
#include "test/cpp/microbenchmarks/fullstack_fixtures.h"

namespace grpc {
namespace testing {

/*******************************************************************************
 * BENCHMARKING KERNELS
 */

// Send next rpc when callback function is evoked.
void SendCallbackUnaryPingPong(benchmark::State& state, EchoRequest* request,
                               EchoResponse* response,
                               EchoTestService::Stub* stub_,
                               bool &done,
                               std::mutex& mu,
                               std::condition_variable& cv) {
  int response_msgs_size = state.range(1);
  ClientContext* cli_ctx = new ClientContext();
  cli_ctx->AddMetadata(kServerMessageSize,
                           grpc::to_string(response_msgs_size));
  stub_->experimental_async()->Echo(
    cli_ctx, request, response,
    [&state, cli_ctx, request, response, stub_, &done, &mu, &cv](Status s) {
    GPR_ASSERT(s.ok());
    if (state.KeepRunning()) {
      SendCallbackUnaryPingPong(state, request, response, stub_, done, mu, cv);
    } else {
      std::lock_guard<std::mutex> l(mu);
      done = true;
      cv.notify_one();
    }
    delete cli_ctx;
  });
}

template <class Fixture, class ClientContextMutator, class ServerContextMutator>
static void BM_CallbackUnaryPingPong(benchmark::State& state) {
  int request_msgs_size = state.range(0);
  int response_msgs_size = state.range(1);
  CallbackStreamingTestService service;
  std::unique_ptr<Fixture> fixture(new Fixture(&service));
  std::unique_ptr<EchoTestService::Stub> stub_(
      EchoTestService::NewStub(fixture->channel()));
  EchoRequest request;
  EchoResponse response;

  if (request_msgs_size > 0) {
    request.set_message(std::string(request_msgs_size, 'a'));
  } else {
    request.set_message("");
  }

  std::mutex mu;
  std::condition_variable cv;
  bool done = false;
  if (state.KeepRunning()) {
    GPR_TIMER_SCOPE("BenchmarkCycle", 0);
    SendCallbackUnaryPingPong(state, &request, &response, stub_.get(),
                              done, mu, cv);
  }
  std::unique_lock<std::mutex> l(mu);
  while (!done) {
    cv.wait(l);
  }
  fixture->Finish(state);
  fixture.reset();
  state.SetBytesProcessed(request_msgs_size * state.iterations() +
                          response_msgs_size * state.iterations());
}


}  // namespace testing
}  // namespace grpc

#endif  // TEST_CPP_MICROBENCHMARKS_FULLSTACK_UNARY_PING_PONG_H