openbilibili/vendor/google.golang.org/grpc/benchmark/grpc_testing/control.proto

// Copyright 2016 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.

syntax = "proto3";

import "payloads.proto";
import "stats.proto";

package grpc.testing;

enum ClientType {
  SYNC_CLIENT = 0;
  ASYNC_CLIENT = 1;
}

enum ServerType {
  SYNC_SERVER = 0;
  ASYNC_SERVER = 1;
  ASYNC_GENERIC_SERVER = 2;
}

enum RpcType {
  UNARY = 0;
  STREAMING = 1;
}

// Parameters of poisson process distribution, which is a good representation
// of activity coming in from independent identical stationary sources.
message PoissonParams {
  // The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
  double offered_load = 1;
}

message UniformParams {
  double interarrival_lo = 1;
  double interarrival_hi = 2;
}

message DeterministicParams {
  double offered_load = 1;
}

message ParetoParams {
  double interarrival_base = 1;
  double alpha = 2;
}

// Once an RPC finishes, immediately start a new one.
// No configuration parameters needed.
message ClosedLoopParams {
}

message LoadParams {
  oneof load {
    ClosedLoopParams closed_loop = 1;
    PoissonParams poisson = 2;
    UniformParams uniform = 3;
    DeterministicParams determ = 4;
    ParetoParams pareto = 5;
  };
}

// presence of SecurityParams implies use of TLS
message SecurityParams {
  bool use_test_ca = 1;
  string server_host_override = 2;
}

message ClientConfig {
  // List of targets to connect to. At least one target needs to be specified.
  repeated string server_targets = 1;
  ClientType client_type = 2;
  SecurityParams security_params = 3;
  // How many concurrent RPCs to start for each channel.
  // For synchronous client, use a separate thread for each outstanding RPC.
  int32 outstanding_rpcs_per_channel = 4;
  // Number of independent client channels to create.
  // i-th channel will connect to server_target[i % server_targets.size()]
  int32 client_channels = 5;
  // Only for async client. Number of threads to use to start/manage RPCs.
  int32 async_client_threads = 7;
  RpcType rpc_type = 8;
  // The requested load for the entire client (aggregated over all the threads).
  LoadParams load_params = 10;
  PayloadConfig payload_config = 11;
  HistogramParams histogram_params = 12;

  // Specify the cores we should run the client on, if desired
  repeated int32 core_list = 13;
  int32 core_limit = 14;
}

message ClientStatus {
  ClientStats stats = 1;
}

// Request current stats
message Mark {
  // if true, the stats will be reset after taking their snapshot.
  bool reset = 1;
}

message ClientArgs {
  oneof argtype {
    ClientConfig setup = 1;
    Mark mark = 2;
  }
}

message ServerConfig {
  ServerType server_type = 1;
  SecurityParams security_params = 2;
  // Port on which to listen. Zero means pick unused port.
  int32 port = 4;
  // Only for async server. Number of threads used to serve the requests.
  int32 async_server_threads = 7;
  // Specify the number of cores to limit server to, if desired
  int32 core_limit = 8;
  // payload config, used in generic server
  PayloadConfig payload_config = 9;

  // Specify the cores we should run the server on, if desired
  repeated int32 core_list = 10;
}

message ServerArgs {
  oneof argtype {
    ServerConfig setup = 1;
    Mark mark = 2;
  }
}

message ServerStatus {
  ServerStats stats = 1;
  // the port bound by the server
  int32 port = 2;
  // Number of cores available to the server
  int32 cores = 3;
}

message CoreRequest {
}

message CoreResponse {
  // Number of cores available on the server
  int32 cores = 1;
}

message Void {
}

// A single performance scenario: input to qps_json_driver
message Scenario {
  // Human readable name for this scenario
  string name = 1;
  // Client configuration
  ClientConfig client_config = 2;
  // Number of clients to start for the test
  int32 num_clients = 3;
  // Server configuration
  ServerConfig server_config = 4;
  // Number of servers to start for the test
  int32 num_servers = 5;
  // Warmup period, in seconds
  int32 warmup_seconds = 6;
  // Benchmark time, in seconds
  int32 benchmark_seconds = 7;
  // Number of workers to spawn locally (usually zero)
  int32 spawn_local_worker_count = 8;
}

// A set of scenarios to be run with qps_json_driver
message Scenarios {
  repeated Scenario scenarios = 1;
}