var ClientType_name = map[int32]string{
    0:  "SYNC_CLIENT",
    1:  "ASYNC_CLIENT",
}

var ClientType_value = map[string]int32{
    "SYNC_CLIENT":  0,
    "ASYNC_CLIENT": 1,
}

var CompressionType_name = map[int32]string{
    0:  "NONE",
    1:  "GZIP",
    2:  "DEFLATE",
}

var CompressionType_value = map[string]int32{
    "NONE":    0,
    "GZIP":    1,
    "DEFLATE": 2,
}

var PayloadType_name = map[int32]string{
    0:  "COMPRESSABLE",
    1:  "UNCOMPRESSABLE",
    2:  "RANDOM",
}

var PayloadType_value = map[string]int32{
    "COMPRESSABLE":   0,
    "UNCOMPRESSABLE": 1,
    "RANDOM":         2,
}

var RpcType_name = map[int32]string{
    0:  "UNARY",
    1:  "STREAMING",
}

var RpcType_value = map[string]int32{
    "UNARY":     0,
    "STREAMING": 1,
}

var ServerType_name = map[int32]string{
    0:  "SYNC_SERVER",
    1:  "ASYNC_SERVER",
    2:  "ASYNC_GENERIC_SERVER",
}

var ServerType_value = map[string]int32{
    "SYNC_SERVER":          0,
    "ASYNC_SERVER":         1,
    "ASYNC_GENERIC_SERVER": 2,
}

type BenchmarkServiceClient interface {
    // One request followed by one response.
    // The server returns the client payload as-is.
    UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
    // One request followed by one response.
    // The server returns the client payload as-is.
    StreamingCall(ctx context.Context, opts ...grpc.CallOption) (BenchmarkService_StreamingCallClient, error)
}

type BenchmarkServiceServer interface {
    // One request followed by one response.
    // The server returns the client payload as-is.
    UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
    // One request followed by one response.
    // The server returns the client payload as-is.
    StreamingCall(BenchmarkService_StreamingCallServer) error
}

type BenchmarkService_StreamingCallClient interface {
    Send(*SimpleRequest) error
    Recv() (*SimpleResponse, error)
    grpc.ClientStream
}

type BenchmarkService_StreamingCallServer interface {
    Send(*SimpleResponse) error
    Recv() (*SimpleRequest, error)
    grpc.ServerStream
}

type ByteBufferParams struct {
    ReqSize  int32 `protobuf:"varint,1,opt,name=req_size,json=reqSize" json:"req_size,omitempty"`
    RespSize int32 `protobuf:"varint,2,opt,name=resp_size,json=respSize" json:"resp_size,omitempty"`
}

type ClientArgs struct {
    // Types that are valid to be assigned to Argtype:
    //	*ClientArgs_Setup
    //	*ClientArgs_Mark
    Argtype isClientArgs_Argtype `protobuf_oneof:"argtype"`
}

type ClientArgs_Mark struct {
    Mark *Mark `protobuf:"bytes,2,opt,name=mark,oneof"`
}

type ClientArgs_Setup struct {
    Setup *ClientConfig `protobuf:"bytes,1,opt,name=setup,oneof"`
}

type ClientConfig struct {
    // List of targets to connect to. At least one target needs to be specified.
    ServerTargets  []string        `protobuf:"bytes,1,rep,name=server_targets,json=serverTargets" json:"server_targets,omitempty"`
    ClientType     ClientType      `protobuf:"varint,2,opt,name=client_type,json=clientType,enum=grpc.testing.ClientType" json:"client_type,omitempty"`
    SecurityParams *SecurityParams `protobuf:"bytes,3,opt,name=security_params,json=securityParams" json:"security_params,omitempty"`
    // How many concurrent RPCs to start for each channel.
    // For synchronous client, use a separate thread for each outstanding RPC.
    OutstandingRpcsPerChannel int32 `protobuf:"varint,4,opt,name=outstanding_rpcs_per_channel,json=outstandingRpcsPerChannel" json:"outstanding_rpcs_per_channel,omitempty"`
    // Number of independent client channels to create.
    // i-th channel will connect to server_target[i % server_targets.size()]
    ClientChannels int32 `protobuf:"varint,5,opt,name=client_channels,json=clientChannels" json:"client_channels,omitempty"`
    // Only for async client. Number of threads to use to start/manage RPCs.
    AsyncClientThreads int32   `protobuf:"varint,7,opt,name=async_client_threads,json=asyncClientThreads" json:"async_client_threads,omitempty"`
    RpcType            RpcType `protobuf:"varint,8,opt,name=rpc_type,json=rpcType,enum=grpc.testing.RpcType" json:"rpc_type,omitempty"`
    // The requested load for the entire client (aggregated over all the threads).
    LoadParams      *LoadParams      `protobuf:"bytes,10,opt,name=load_params,json=loadParams" json:"load_params,omitempty"`
    PayloadConfig   *PayloadConfig   `protobuf:"bytes,11,opt,name=payload_config,json=payloadConfig" json:"payload_config,omitempty"`
    HistogramParams *HistogramParams `protobuf:"bytes,12,opt,name=histogram_params,json=histogramParams" json:"histogram_params,omitempty"`
    // Specify the cores we should run the client on, if desired
    CoreList  []int32 `protobuf:"varint,13,rep,name=core_list,json=coreList" json:"core_list,omitempty"`
    CoreLimit int32   `protobuf:"varint,14,opt,name=core_limit,json=coreLimit" json:"core_limit,omitempty"`
}

type ClientStats struct {
    // Latency histogram. Data points are in nanoseconds.
    Latencies *HistogramData `protobuf:"bytes,1,opt,name=latencies" json:"latencies,omitempty"`
    // See ServerStats for details.
    TimeElapsed float64 `protobuf:"fixed64,2,opt,name=time_elapsed,json=timeElapsed" json:"time_elapsed,omitempty"`
    TimeUser    float64 `protobuf:"fixed64,3,opt,name=time_user,json=timeUser" json:"time_user,omitempty"`
    TimeSystem  float64 `protobuf:"fixed64,4,opt,name=time_system,json=timeSystem" json:"time_system,omitempty"`
}

type ClientStatus struct {
    Stats *ClientStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
}

type ClientType int32

const (
    ClientType_SYNC_CLIENT  ClientType = 0
    ClientType_ASYNC_CLIENT ClientType = 1
)

type ClosedLoopParams struct {
}

type ComplexProtoParams struct {
}

type CompressionType int32

const (
    // No compression
    CompressionType_NONE    CompressionType = 0
    CompressionType_GZIP    CompressionType = 1
    CompressionType_DEFLATE CompressionType = 2
)

type CoreRequest struct {
}

type CoreResponse struct {
    // Number of cores available on the server
    Cores int32 `protobuf:"varint,1,opt,name=cores" json:"cores,omitempty"`
}

type DeterministicParams struct {
    OfferedLoad float64 `protobuf:"fixed64,1,opt,name=offered_load,json=offeredLoad" json:"offered_load,omitempty"`
}

type EchoStatus struct {
    Code    int32  `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
    Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
}

type HistogramData struct {
    Bucket       []uint32 `protobuf:"varint,1,rep,name=bucket" json:"bucket,omitempty"`
    MinSeen      float64  `protobuf:"fixed64,2,opt,name=min_seen,json=minSeen" json:"min_seen,omitempty"`
    MaxSeen      float64  `protobuf:"fixed64,3,opt,name=max_seen,json=maxSeen" json:"max_seen,omitempty"`
    Sum          float64  `protobuf:"fixed64,4,opt,name=sum" json:"sum,omitempty"`
    SumOfSquares float64  `protobuf:"fixed64,5,opt,name=sum_of_squares,json=sumOfSquares" json:"sum_of_squares,omitempty"`
    Count        float64  `protobuf:"fixed64,6,opt,name=count" json:"count,omitempty"`
}

type HistogramParams struct {
    Resolution  float64 `protobuf:"fixed64,1,opt,name=resolution" json:"resolution,omitempty"`
    MaxPossible float64 `protobuf:"fixed64,2,opt,name=max_possible,json=maxPossible" json:"max_possible,omitempty"`
}

type LoadParams struct {
    // Types that are valid to be assigned to Load:
    //	*LoadParams_ClosedLoop
    //	*LoadParams_Poisson
    //	*LoadParams_Uniform
    //	*LoadParams_Determ
    //	*LoadParams_Pareto
    Load isLoadParams_Load `protobuf_oneof:"load"`
}

type LoadParams_ClosedLoop struct {
    ClosedLoop *ClosedLoopParams `protobuf:"bytes,1,opt,name=closed_loop,json=closedLoop,oneof"`
}

type LoadParams_Determ struct {
    Determ *DeterministicParams `protobuf:"bytes,4,opt,name=determ,oneof"`
}

type LoadParams_Pareto struct {
    Pareto *ParetoParams `protobuf:"bytes,5,opt,name=pareto,oneof"`
}

type LoadParams_Poisson struct {
    Poisson *PoissonParams `protobuf:"bytes,2,opt,name=poisson,oneof"`
}

type LoadParams_Uniform struct {
    Uniform *UniformParams `protobuf:"bytes,3,opt,name=uniform,oneof"`
}

type Mark struct {
    // if true, the stats will be reset after taking their snapshot.
    Reset_ bool `protobuf:"varint,1,opt,name=reset" json:"reset,omitempty"`
}

type ParetoParams struct {
    InterarrivalBase float64 `protobuf:"fixed64,1,opt,name=interarrival_base,json=interarrivalBase" json:"interarrival_base,omitempty"`
    Alpha            float64 `protobuf:"fixed64,2,opt,name=alpha" json:"alpha,omitempty"`
}

type Payload struct {
    // The type of data in body.
    Type PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
    // Primary contents of payload.
    Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}

type PayloadConfig struct {
    // Types that are valid to be assigned to Payload:
    //	*PayloadConfig_BytebufParams
    //	*PayloadConfig_SimpleParams
    //	*PayloadConfig_ComplexParams
    Payload isPayloadConfig_Payload `protobuf_oneof:"payload"`
}

type PayloadConfig_BytebufParams struct {
    BytebufParams *ByteBufferParams `protobuf:"bytes,1,opt,name=bytebuf_params,json=bytebufParams,oneof"`
}

type PayloadConfig_ComplexParams struct {
    ComplexParams *ComplexProtoParams `protobuf:"bytes,3,opt,name=complex_params,json=complexParams,oneof"`
}

type PayloadConfig_SimpleParams struct {
    SimpleParams *SimpleProtoParams `protobuf:"bytes,2,opt,name=simple_params,json=simpleParams,oneof"`
}

type PayloadType int32

const (
    // Compressable text format.
    PayloadType_COMPRESSABLE PayloadType = 0
    // Uncompressable binary format.
    PayloadType_UNCOMPRESSABLE PayloadType = 1
    // Randomly chosen from all other formats defined in this enum.
    PayloadType_RANDOM PayloadType = 2
)

type PoissonParams struct {
    // The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
    OfferedLoad float64 `protobuf:"fixed64,1,opt,name=offered_load,json=offeredLoad" json:"offered_load,omitempty"`
}

type ReconnectInfo struct {
    Passed    bool    `protobuf:"varint,1,opt,name=passed" json:"passed,omitempty"`
    BackoffMs []int32 `protobuf:"varint,2,rep,name=backoff_ms,json=backoffMs" json:"backoff_ms,omitempty"`
}

type ReconnectParams struct {
    MaxReconnectBackoffMs int32 `protobuf:"varint,1,opt,name=max_reconnect_backoff_ms,json=maxReconnectBackoffMs" json:"max_reconnect_backoff_ms,omitempty"`
}

type ResponseParameters struct {
    // Desired payload sizes in responses from the server.
    // If response_type is COMPRESSABLE, this denotes the size before compression.
    Size int32 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
    // Desired interval between consecutive responses in the response stream in
    // microseconds.
    IntervalUs int32 `protobuf:"varint,2,opt,name=interval_us,json=intervalUs" json:"interval_us,omitempty"`
}

type RpcType int32

const (
    RpcType_UNARY     RpcType = 0
    RpcType_STREAMING RpcType = 1
)

type Scenario struct {
    // Human readable name for this scenario
    Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
    // Client configuration
    ClientConfig *ClientConfig `protobuf:"bytes,2,opt,name=client_config,json=clientConfig" json:"client_config,omitempty"`
    // Number of clients to start for the test
    NumClients int32 `protobuf:"varint,3,opt,name=num_clients,json=numClients" json:"num_clients,omitempty"`
    // Server configuration
    ServerConfig *ServerConfig `protobuf:"bytes,4,opt,name=server_config,json=serverConfig" json:"server_config,omitempty"`
    // Number of servers to start for the test
    NumServers int32 `protobuf:"varint,5,opt,name=num_servers,json=numServers" json:"num_servers,omitempty"`
    // Warmup period, in seconds
    WarmupSeconds int32 `protobuf:"varint,6,opt,name=warmup_seconds,json=warmupSeconds" json:"warmup_seconds,omitempty"`
    // Benchmark time, in seconds
    BenchmarkSeconds int32 `protobuf:"varint,7,opt,name=benchmark_seconds,json=benchmarkSeconds" json:"benchmark_seconds,omitempty"`
    // Number of workers to spawn locally (usually zero)
    SpawnLocalWorkerCount int32 `protobuf:"varint,8,opt,name=spawn_local_worker_count,json=spawnLocalWorkerCount" json:"spawn_local_worker_count,omitempty"`
}

type Scenarios struct {
    Scenarios []*Scenario `protobuf:"bytes,1,rep,name=scenarios" json:"scenarios,omitempty"`
}

type SecurityParams struct {
    UseTestCa          bool   `protobuf:"varint,1,opt,name=use_test_ca,json=useTestCa" json:"use_test_ca,omitempty"`
    ServerHostOverride string `protobuf:"bytes,2,opt,name=server_host_override,json=serverHostOverride" json:"server_host_override,omitempty"`
}

type ServerArgs struct {
    // Types that are valid to be assigned to Argtype:
    //	*ServerArgs_Setup
    //	*ServerArgs_Mark
    Argtype isServerArgs_Argtype `protobuf_oneof:"argtype"`
}

type ServerArgs_Mark struct {
    Mark *Mark `protobuf:"bytes,2,opt,name=mark,oneof"`
}

type ServerArgs_Setup struct {
    Setup *ServerConfig `protobuf:"bytes,1,opt,name=setup,oneof"`
}

type ServerConfig struct {
    ServerType     ServerType      `protobuf:"varint,1,opt,name=server_type,json=serverType,enum=grpc.testing.ServerType" json:"server_type,omitempty"`
    SecurityParams *SecurityParams `protobuf:"bytes,2,opt,name=security_params,json=securityParams" json:"security_params,omitempty"`
    // Port on which to listen. Zero means pick unused port.
    Port int32 `protobuf:"varint,4,opt,name=port" json:"port,omitempty"`
    // Only for async server. Number of threads used to serve the requests.
    AsyncServerThreads int32 `protobuf:"varint,7,opt,name=async_server_threads,json=asyncServerThreads" json:"async_server_threads,omitempty"`
    // Specify the number of cores to limit server to, if desired
    CoreLimit int32 `protobuf:"varint,8,opt,name=core_limit,json=coreLimit" json:"core_limit,omitempty"`
    // payload config, used in generic server
    PayloadConfig *PayloadConfig `protobuf:"bytes,9,opt,name=payload_config,json=payloadConfig" json:"payload_config,omitempty"`
    // Specify the cores we should run the server on, if desired
    CoreList []int32 `protobuf:"varint,10,rep,name=core_list,json=coreList" json:"core_list,omitempty"`
}

type ServerStats struct {
    // wall clock time change in seconds since last reset
    TimeElapsed float64 `protobuf:"fixed64,1,opt,name=time_elapsed,json=timeElapsed" json:"time_elapsed,omitempty"`
    // change in user time (in seconds) used by the server since last reset
    TimeUser float64 `protobuf:"fixed64,2,opt,name=time_user,json=timeUser" json:"time_user,omitempty"`
    // change in server time (in seconds) used by the server process and all
    // threads since last reset
    TimeSystem float64 `protobuf:"fixed64,3,opt,name=time_system,json=timeSystem" json:"time_system,omitempty"`
}

type ServerStatus struct {
    Stats *ServerStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
    // the port bound by the server
    Port int32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
    // Number of cores available to the server
    Cores int32 `protobuf:"varint,3,opt,name=cores" json:"cores,omitempty"`
}

type ServerType int32

const (
    ServerType_SYNC_SERVER          ServerType = 0
    ServerType_ASYNC_SERVER         ServerType = 1
    ServerType_ASYNC_GENERIC_SERVER ServerType = 2
)

type SimpleProtoParams struct {
    ReqSize  int32 `protobuf:"varint,1,opt,name=req_size,json=reqSize" json:"req_size,omitempty"`
    RespSize int32 `protobuf:"varint,2,opt,name=resp_size,json=respSize" json:"resp_size,omitempty"`
}

type SimpleRequest struct {
    // Desired payload type in the response from the server.
    // If response_type is RANDOM, server randomly chooses one from other formats.
    ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
    // Desired payload size in the response from the server.
    // If response_type is COMPRESSABLE, this denotes the size before compression.
    ResponseSize int32 `protobuf:"varint,2,opt,name=response_size,json=responseSize" json:"response_size,omitempty"`
    // Optional input payload sent along with the request.
    Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
    // Whether SimpleResponse should include username.
    FillUsername bool `protobuf:"varint,4,opt,name=fill_username,json=fillUsername" json:"fill_username,omitempty"`
    // Whether SimpleResponse should include OAuth scope.
    FillOauthScope bool `protobuf:"varint,5,opt,name=fill_oauth_scope,json=fillOauthScope" json:"fill_oauth_scope,omitempty"`
    // Compression algorithm to be used by the server for the response (stream)
    ResponseCompression CompressionType `protobuf:"varint,6,opt,name=response_compression,json=responseCompression,enum=grpc.testing.CompressionType" json:"response_compression,omitempty"`
    // Whether server should return a given status
    ResponseStatus *EchoStatus `protobuf:"bytes,7,opt,name=response_status,json=responseStatus" json:"response_status,omitempty"`
}

type SimpleResponse struct {
    // Payload to increase message size.
    Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
    // The user the request came from, for verifying authentication was
    // successful when the client expected it.
    Username string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"`
    // OAuth scope.
    OauthScope string `protobuf:"bytes,3,opt,name=oauth_scope,json=oauthScope" json:"oauth_scope,omitempty"`
}

type StreamingInputCallRequest struct {
    // Optional input payload sent along with the request.
    Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
}

type StreamingInputCallResponse struct {
    // Aggregated size of payloads received from the client.
    AggregatedPayloadSize int32 `protobuf:"varint,1,opt,name=aggregated_payload_size,json=aggregatedPayloadSize" json:"aggregated_payload_size,omitempty"`
}

type StreamingOutputCallRequest struct {
    // Desired payload type in the response from the server.
    // If response_type is RANDOM, the payload from each response in the stream
    // might be of different types. This is to simulate a mixed type of payload
    // stream.
    ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
    // Configuration for each expected response message.
    ResponseParameters []*ResponseParameters `protobuf:"bytes,2,rep,name=response_parameters,json=responseParameters" json:"response_parameters,omitempty"`
    // Optional input payload sent along with the request.
    Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
    // Compression algorithm to be used by the server for the response (stream)
    ResponseCompression CompressionType `protobuf:"varint,6,opt,name=response_compression,json=responseCompression,enum=grpc.testing.CompressionType" json:"response_compression,omitempty"`
    // Whether server should return a given status
    ResponseStatus *EchoStatus `protobuf:"bytes,7,opt,name=response_status,json=responseStatus" json:"response_status,omitempty"`
}

type StreamingOutputCallResponse struct {
    // Payload to increase response size.
    Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
}

type UniformParams struct {
    InterarrivalLo float64 `protobuf:"fixed64,1,opt,name=interarrival_lo,json=interarrivalLo" json:"interarrival_lo,omitempty"`
    InterarrivalHi float64 `protobuf:"fixed64,2,opt,name=interarrival_hi,json=interarrivalHi" json:"interarrival_hi,omitempty"`
}

type Void struct {
}

type WorkerServiceClient interface {
    // Start server with specified workload.
    // First request sent specifies the ServerConfig followed by ServerStatus
    // response. After that, a "Mark" can be sent anytime to request the latest
    // stats. Closing the stream will initiate shutdown of the test server
    // and once the shutdown has finished, the OK status is sent to terminate
    // this RPC.
    RunServer(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunServerClient, error)
    // Start client with specified workload.
    // First request sent specifies the ClientConfig followed by ClientStatus
    // response. After that, a "Mark" can be sent anytime to request the latest
    // stats. Closing the stream will initiate shutdown of the test client
    // and once the shutdown has finished, the OK status is sent to terminate
    // this RPC.
    RunClient(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunClientClient, error)
    // Just return the core count - unary call
    CoreCount(ctx context.Context, in *CoreRequest, opts ...grpc.CallOption) (*CoreResponse, error)
    // Quit this worker
    QuitWorker(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Void, error)
}

type WorkerServiceServer interface {
    // Start server with specified workload.
    // First request sent specifies the ServerConfig followed by ServerStatus
    // response. After that, a "Mark" can be sent anytime to request the latest
    // stats. Closing the stream will initiate shutdown of the test server
    // and once the shutdown has finished, the OK status is sent to terminate
    // this RPC.
    RunServer(WorkerService_RunServerServer) error
    // Start client with specified workload.
    // First request sent specifies the ClientConfig followed by ClientStatus
    // response. After that, a "Mark" can be sent anytime to request the latest
    // stats. Closing the stream will initiate shutdown of the test client
    // and once the shutdown has finished, the OK status is sent to terminate
    // this RPC.
    RunClient(WorkerService_RunClientServer) error
    // Just return the core count - unary call
    CoreCount(context.Context, *CoreRequest) (*CoreResponse, error)
    // Quit this worker
    QuitWorker(context.Context, *Void) (*Void, error)
}

type WorkerService_RunClientClient interface {
    Send(*ClientArgs) error
    Recv() (*ClientStatus, error)
    grpc.ClientStream
}

type WorkerService_RunClientServer interface {
    Send(*ClientStatus) error
    Recv() (*ClientArgs, error)
    grpc.ServerStream
}

type WorkerService_RunServerClient interface {
    Send(*ServerArgs) error
    Recv() (*ServerStatus, error)
    grpc.ClientStream
}

type WorkerService_RunServerServer interface {
    Send(*ServerStatus) error
    Recv() (*ServerArgs, error)
    grpc.ServerStream
}