for_core_protos_go_proto

type AvailableDeviceInfo struct {
	Name                string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`                                                          // Device name.
	Type                string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`                                                          // Device type, e.g. 'CPU' or 'GPU'.
	MemoryLimit         int64  `protobuf:"varint,3,opt,name=memory_limit,json=memoryLimit,proto3" json:"memory_limit,omitempty"`                        // Memory capacity in bytes.
	PhysicalDescription string `protobuf:"bytes,4,opt,name=physical_description,json=physicalDescription,proto3" json:"physical_description,omitempty"` // The physical description of this device.
	// contains filtered or unexported fields
}

type BarrierRequest struct {
	BarrierId          string `protobuf:"bytes,1,opt,name=barrier_id,json=barrierId,proto3" json:"barrier_id,omitempty"`
	BarrierTimeoutInMs int64  `protobuf:"varint,2,opt,name=barrier_timeout_in_ms,json=barrierTimeoutInMs,proto3" json:"barrier_timeout_in_ms,omitempty"`
	// Denotes list of tasks that will wait for the barrier. If unspecified, it
	// implies that the entire cluster is participating in the barrier.
	Tasks []*CoordinatedTask `protobuf:"bytes,3,rep,name=tasks,proto3" json:"tasks,omitempty"`
	// Task that is making the request.
	SourceTask *CoordinatedTask `protobuf:"bytes,4,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type BarrierResponse struct {
	// contains filtered or unexported fields
}

type BenchmarkEntries struct {
	Entry []*BenchmarkEntry `protobuf:"bytes,1,rep,name=entry,proto3" json:"entry,omitempty"`
	// contains filtered or unexported fields
}

type BenchmarkEntry struct {

	// The name of the specific benchmark or test
	// (e.g. BM_AdjustContrast_gpu_B_W_H)
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If a benchmark, how many iterations it was run for
	Iters int64 `protobuf:"varint,2,opt,name=iters,proto3" json:"iters,omitempty"`
	// Total cpu time used for all iterations (in seconds)
	CpuTime float64 `protobuf:"fixed64,3,opt,name=cpu_time,json=cpuTime,proto3" json:"cpu_time,omitempty"`
	// Total wall time used for all iterations (in seconds)
	WallTime float64 `protobuf:"fixed64,4,opt,name=wall_time,json=wallTime,proto3" json:"wall_time,omitempty"`
	// Throughput (in MB/s)
	Throughput float64 `protobuf:"fixed64,5,opt,name=throughput,proto3" json:"throughput,omitempty"`
	// Generic map from result key to value.
	Extras map[string]*EntryValue `` /* 153-byte string literal not displayed */
	// Metric name, value and expected range. This can include accuracy metrics
	// typically used to determine whether the accuracy test has passed
	Metrics []*MetricEntry `protobuf:"bytes,7,rep,name=metrics,proto3" json:"metrics,omitempty"`
	// contains filtered or unexported fields
}

type BinSummary struct {
	Bin              int32 `protobuf:"varint,1,opt,name=bin,proto3" json:"bin,omitempty"`
	TotalBytesInUse  int64 `protobuf:"varint,2,opt,name=total_bytes_in_use,json=totalBytesInUse,proto3" json:"total_bytes_in_use,omitempty"`
	TotalBytesInBin  int64 `protobuf:"varint,3,opt,name=total_bytes_in_bin,json=totalBytesInBin,proto3" json:"total_bytes_in_bin,omitempty"`
	TotalChunksInUse int64 `protobuf:"varint,4,opt,name=total_chunks_in_use,json=totalChunksInUse,proto3" json:"total_chunks_in_use,omitempty"`
	TotalChunksInBin int64 `protobuf:"varint,5,opt,name=total_chunks_in_bin,json=totalChunksInBin,proto3" json:"total_chunks_in_bin,omitempty"`
	// contains filtered or unexported fields
}

type BuildConfiguration struct {
	Mode    string   `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`                      // opt, dbg, etc
	CcFlags []string `protobuf:"bytes,2,rep,name=cc_flags,json=ccFlags,proto3" json:"cc_flags,omitempty"` // CC compiler flags, if known
	Opts    []string `protobuf:"bytes,3,rep,name=opts,proto3" json:"opts,omitempty"`                      // Bazel compilation options, if known
	// contains filtered or unexported fields
}

type CPUInfo struct {
	NumCores        int64 `protobuf:"varint,1,opt,name=num_cores,json=numCores,proto3" json:"num_cores,omitempty"`
	NumCoresAllowed int64 `protobuf:"varint,2,opt,name=num_cores_allowed,json=numCoresAllowed,proto3" json:"num_cores_allowed,omitempty"`
	// How fast are these cpus?
	MhzPerCpu float64 `protobuf:"fixed64,3,opt,name=mhz_per_cpu,json=mhzPerCpu,proto3" json:"mhz_per_cpu,omitempty"`
	// Additional cpu information. For example,
	// Intel Ivybridge with HyperThreading (24 cores) dL1:32KB dL2:256KB dL3:30MB
	CpuInfo string `protobuf:"bytes,4,opt,name=cpu_info,json=cpuInfo,proto3" json:"cpu_info,omitempty"`
	// What kind of cpu scaling is enabled on the host.
	// Examples include "performance", "ondemand", "conservative", "mixed".
	CpuGovernor string `protobuf:"bytes,5,opt,name=cpu_governor,json=cpuGovernor,proto3" json:"cpu_governor,omitempty"`
	// Cache sizes (in bytes), e.g. "L2": 262144 (for 256KB)
	CacheSize map[string]int64 `` /* 177-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CancelBarrierRequest struct {
	BarrierId string `protobuf:"bytes,1,opt,name=barrier_id,json=barrierId,proto3" json:"barrier_id,omitempty"`
	// Task that is making the request.
	SourceTask *CoordinatedTask `protobuf:"bytes,2,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type CancelBarrierResponse struct {
	// contains filtered or unexported fields
}

type Code int32

type CommitId struct {

	// Types that are assignable to Kind:
	//
	//	*CommitId_Changelist
	//	*CommitId_Hash
	Kind isCommitId_Kind `protobuf_oneof:"kind"`
	// Hash of intermediate change between hash/changelist and what was tested.
	// Not used if the build is from a commit without modifications.
	Snapshot string `protobuf:"bytes,3,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// Changelist tested if the change list is not already submitted.
	PendingChangelist int64 `protobuf:"varint,4,opt,name=pending_changelist,json=pendingChangelist,proto3" json:"pending_changelist,omitempty"`
	// contains filtered or unexported fields
}

type CommitId_Changelist struct {
	// Submitted changelist.
	Changelist int64 `protobuf:"varint,1,opt,name=changelist,proto3,oneof"`
}

type CommitId_Hash struct {
	Hash string `protobuf:"bytes,2,opt,name=hash,proto3,oneof"`
}

type CoordinatedJob struct {
	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	NumTasks int32  `protobuf:"varint,2,opt,name=num_tasks,json=numTasks,proto3" json:"num_tasks,omitempty"`
	// contains filtered or unexported fields
}

type CoordinatedTask struct {
	JobName string `protobuf:"bytes,1,opt,name=job_name,json=jobName,proto3" json:"job_name,omitempty"`
	TaskId  int32  `protobuf:"varint,2,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// contains filtered or unexported fields
}

type CoordinatedTaskState int32

type CoordinatedTaskStateInfo struct {
	Task         *CoordinatedTask          `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	State        CoordinatedTaskState      `protobuf:"varint,2,opt,name=state,proto3,enum=tensorflow.CoordinatedTaskState" json:"state,omitempty"`
	ErrorCode    int32                     `protobuf:"varint,3,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"`
	ErrorMessage string                    `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	ErrorPayload *CoordinationServiceError `protobuf:"bytes,5,opt,name=error_payload,json=errorPayload,proto3" json:"error_payload,omitempty"`
	// contains filtered or unexported fields
}

type CoordinationServiceClient interface {
	// Register task to coordination service so that the service starts to track
	// liveness of the task. RPC blocks and returns only when it registers to
	// the service successfully, or error happens in the registering process.
	RegisterTask(ctx context.Context, in *RegisterTaskRequest, opts ...grpc.CallOption) (*RegisterTaskResponse, error)
	// Heartbeat message from task to coordination service. Heartbeat is sent from
	// a task to refresh its timestamp on leader to avoid it becoming stale.
	// RPC responds immediately after refreshing the timestamp on leader.
	Heartbeat(ctx context.Context, in *HeartbeatRequest, opts ...grpc.CallOption) (*HeartbeatResponse, error)
	// Wait for all tasks in the cluster to be up and running. The RPC request
	// only gets responded when all tasks have registered, or some error occurs.
	WaitForAllTasks(ctx context.Context, in *WaitForAllTasksRequest, opts ...grpc.CallOption) (*WaitForAllTasksResponse, error)
	// Disconnects task from the service. If `shutdown_barrier_timeout_in_ms` is
	// specified in the config, blocks until all tasks reach the barrier before
	// disconnecting together. If the barrier times out, tasks at the barrier will
	// still disconnect, while an error is reported to tasks that did not reach
	// the barrier on time.
	ShutdownTask(ctx context.Context, in *ShutdownTaskRequest, opts ...grpc.CallOption) (*ShutdownTaskResponse, error)
	// Disconnects task from the service if it is in an ERROR state, thereby
	// allowing it to reconnect via RegisterTask() in the future.
	ResetTask(ctx context.Context, in *ResetTaskRequest, opts ...grpc.CallOption) (*ResetTaskResponse, error)
	// Report error to the task. RPC sets the receiving instance of coordination
	// service agent to error state permanently.
	// TODO(b/195990880): Consider splitting this into a different RPC service.
	ReportErrorToTask(ctx context.Context, in *ReportErrorToTaskRequest, opts ...grpc.CallOption) (*ReportErrorToTaskResponse, error)
	// Report task error to coordination service. RPC sets the service-side task
	// state to error, and propagate the error to other tasks in the cluster.
	ReportErrorToService(ctx context.Context, in *ReportErrorToServiceRequest, opts ...grpc.CallOption) (*ReportErrorToServiceResponse, error)
	// Get the state of a remote task. Specifically, RPC returns a
	// CoordinatedTaskState, and if the task is in an error status, returns a
	// non-OK error code, non-empty error message and error payload.
	GetTaskState(ctx context.Context, in *GetTaskStateRequest, opts ...grpc.CallOption) (*GetTaskStateResponse, error)
	// Insert configuration key-value that will be accessible to all cluster
	// tasks. The key can be formatted as Unix file path with hierarchy. The
	// coordination service key-value store should only be used for cluster
	// configuration data.
	InsertKeyValue(ctx context.Context, in *InsertKeyValueRequest, opts ...grpc.CallOption) (*InsertKeyValueResponse, error)
	// Get configuration key-value. The request blocks until the key-value data
	// becomes available (i.e., set by a task in the cluster).
	GetKeyValue(ctx context.Context, in *GetKeyValueRequest, opts ...grpc.CallOption) (*GetKeyValueResponse, error)
	// Get configuration key-value. The request does not block, but returns an
	// error if the requested key does not exist.
	TryGetKeyValue(ctx context.Context, in *TryGetKeyValueRequest, opts ...grpc.CallOption) (*TryGetKeyValueResponse, error)
	// Same as GetKeyValue, but returns all values that have keys which are
	// prefixed with the directory key.
	GetKeyValueDir(ctx context.Context, in *GetKeyValueDirRequest, opts ...grpc.CallOption) (*GetKeyValueDirResponse, error)
	// Delete configuration key-value. If is_directory is set in request,
	// recursively clean up all key-values under the path specified by `key`.
	DeleteKeyValue(ctx context.Context, in *DeleteKeyValueRequest, opts ...grpc.CallOption) (*DeleteKeyValueResponse, error)
	// Blocks until all (or a subset of) tasks are at the barrier or the barrier
	// fails.
	//
	// `barrier_id` should be unique across barriers. Once the barrier has passed
	// or failed, subsequent calls will not block, and immediately respond with
	// the previous response.
	//
	// The first WaitAtBarrier() call received by the service for a particular
	// barrier id is special in that it determines the barrier deadline based on
	// timeout duration.
	// However, if subsequent calls by different agents specify a different set of
	// `tasks` for the same `barrier_id`, the barrier will fail instantly.
	//
	// If no tasks are specified (default), the barrier will block for all the
	// connected tasks.
	//
	// Possible service errors:
	//   - DeadlineExceeded: Timed out waiting for specified tasks at the barrier.
	//     Deadline is determined by the server timestamp when it receives the
	//     first WaitAtBarrier() + timeout duration.
	//   - Cancelled: One of the tasks called CancelBarrier().
	//   - Aborted: Service is shutting down.
	//   - Internal: Any participating task is in ERROR state.
	//   - InvalidArgument: (1) Conflicting tasks specified by different agents
	//     for the same barrier, (2) one of the participating tasks is not in
	//     the cluster, or (3) task making the request is not included in the
	//     list of participating tasks.
	Barrier(ctx context.Context, in *BarrierRequest, opts ...grpc.CallOption) (*BarrierResponse, error)
	// Aborts the barrier if it is ongoing.
	// Current and future WaitAtBarrier() calls with the same id will return a
	// CANCELLED error status.
	// Possible service errors:
	//   - FailedPrecondition: Barrier has already been passed.
	CancelBarrier(ctx context.Context, in *CancelBarrierRequest, opts ...grpc.CallOption) (*CancelBarrierResponse, error)
}

type CoordinationServiceConfig struct {

	// Type of coordination service implementation to enable.
	// For example, setting the service type as "standalone" starts a service
	// instance on the leader task to provide the coordination services such as
	// heartbeats and consistent key-value store.
	ServiceType string `protobuf:"bytes,1,opt,name=service_type,json=serviceType,proto3" json:"service_type,omitempty"`
	// Address where the coordination service instance is hosted.
	ServiceLeader string `protobuf:"bytes,2,opt,name=service_leader,json=serviceLeader,proto3" json:"service_leader,omitempty"`
	// Whether to enable the health check mechanism.
	EnableHealthCheck bool `protobuf:"varint,3,opt,name=enable_health_check,json=enableHealthCheck,proto3" json:"enable_health_check,omitempty"`
	// Maximum wait time for all members in the cluster to be registered.
	ClusterRegisterTimeoutInMs int64 `` /* 146-byte string literal not displayed */
	// Heartbeat timeout, if a task does not record heartbeat in this time
	// window, it will be considered disconnected.
	// Note: This is also used as a grace period to accept any heartbeats after
	// the agent has disconnected, to account for the lag time between the service
	// recording the state change and the agent stopping heartbeats.
	HeartbeatTimeoutInMs int64             `` /* 126-byte string literal not displayed */
	CoordinatedJobList   []*CoordinatedJob `protobuf:"bytes,10,rep,name=coordinated_job_list,json=coordinatedJobList,proto3" json:"coordinated_job_list,omitempty"`
	// Denotes how long to wait for all coordination agents to reach the barriers
	// (after the first shutdown request) before disconnecting together. If
	// set to 0, no barrier is imposed upon shutdown and each worker can
	// disconnect individually.
	ShutdownBarrierTimeoutInMs int64 `` /* 146-byte string literal not displayed */
	// If set, agents do not make an explicit Shutdown() call. Service will only
	// find out about the disconnecte agent via stale heartbeats. Used for
	// testing.
	AgentDestructionWithoutShutdown bool `` /* 159-byte string literal not displayed */
	// The list of jobs which are recoverable. If a task in this list fails,
	// it will not propagate error to other tasks.
	// If empty, no jobs will be recoverable and every task failure will cause
	// error propagation to other tasks.
	RecoverableJobs []string `protobuf:"bytes,9,rep,name=recoverable_jobs,json=recoverableJobs,proto3" json:"recoverable_jobs,omitempty"`
	// If a task restarts with a new incarnation, we may allow it to reconnect
	// silently. This is useful when we know that a task can immediately resume
	// work upon re-connecting to the service.
	AllowNewIncarnationToReconnect bool `` /* 159-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CoordinationServiceError struct {

	// If true, error is reported via the agent API by the user (and not an
	// internal service error).
	IsReportedError bool `protobuf:"varint,3,opt,name=is_reported_error,json=isReportedError,proto3" json:"is_reported_error,omitempty"`
	// Denotes which task hit the error. If unset, the error originated from the
	// same task that is processing this error.
	SourceTask *CoordinatedTask `protobuf:"bytes,4,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type CoordinationServiceServer interface {
	// Register task to coordination service so that the service starts to track
	// liveness of the task. RPC blocks and returns only when it registers to
	// the service successfully, or error happens in the registering process.
	RegisterTask(context.Context, *RegisterTaskRequest) (*RegisterTaskResponse, error)
	// Heartbeat message from task to coordination service. Heartbeat is sent from
	// a task to refresh its timestamp on leader to avoid it becoming stale.
	// RPC responds immediately after refreshing the timestamp on leader.
	Heartbeat(context.Context, *HeartbeatRequest) (*HeartbeatResponse, error)
	// Wait for all tasks in the cluster to be up and running. The RPC request
	// only gets responded when all tasks have registered, or some error occurs.
	WaitForAllTasks(context.Context, *WaitForAllTasksRequest) (*WaitForAllTasksResponse, error)
	// Disconnects task from the service. If `shutdown_barrier_timeout_in_ms` is
	// specified in the config, blocks until all tasks reach the barrier before
	// disconnecting together. If the barrier times out, tasks at the barrier will
	// still disconnect, while an error is reported to tasks that did not reach
	// the barrier on time.
	ShutdownTask(context.Context, *ShutdownTaskRequest) (*ShutdownTaskResponse, error)
	// Disconnects task from the service if it is in an ERROR state, thereby
	// allowing it to reconnect via RegisterTask() in the future.
	ResetTask(context.Context, *ResetTaskRequest) (*ResetTaskResponse, error)
	// Report error to the task. RPC sets the receiving instance of coordination
	// service agent to error state permanently.
	// TODO(b/195990880): Consider splitting this into a different RPC service.
	ReportErrorToTask(context.Context, *ReportErrorToTaskRequest) (*ReportErrorToTaskResponse, error)
	// Report task error to coordination service. RPC sets the service-side task
	// state to error, and propagate the error to other tasks in the cluster.
	ReportErrorToService(context.Context, *ReportErrorToServiceRequest) (*ReportErrorToServiceResponse, error)
	// Get the state of a remote task. Specifically, RPC returns a
	// CoordinatedTaskState, and if the task is in an error status, returns a
	// non-OK error code, non-empty error message and error payload.
	GetTaskState(context.Context, *GetTaskStateRequest) (*GetTaskStateResponse, error)
	// Insert configuration key-value that will be accessible to all cluster
	// tasks. The key can be formatted as Unix file path with hierarchy. The
	// coordination service key-value store should only be used for cluster
	// configuration data.
	InsertKeyValue(context.Context, *InsertKeyValueRequest) (*InsertKeyValueResponse, error)
	// Get configuration key-value. The request blocks until the key-value data
	// becomes available (i.e., set by a task in the cluster).
	GetKeyValue(context.Context, *GetKeyValueRequest) (*GetKeyValueResponse, error)
	// Get configuration key-value. The request does not block, but returns an
	// error if the requested key does not exist.
	TryGetKeyValue(context.Context, *TryGetKeyValueRequest) (*TryGetKeyValueResponse, error)
	// Same as GetKeyValue, but returns all values that have keys which are
	// prefixed with the directory key.
	GetKeyValueDir(context.Context, *GetKeyValueDirRequest) (*GetKeyValueDirResponse, error)
	// Delete configuration key-value. If is_directory is set in request,
	// recursively clean up all key-values under the path specified by `key`.
	DeleteKeyValue(context.Context, *DeleteKeyValueRequest) (*DeleteKeyValueResponse, error)
	// Blocks until all (or a subset of) tasks are at the barrier or the barrier
	// fails.
	//
	// `barrier_id` should be unique across barriers. Once the barrier has passed
	// or failed, subsequent calls will not block, and immediately respond with
	// the previous response.
	//
	// The first WaitAtBarrier() call received by the service for a particular
	// barrier id is special in that it determines the barrier deadline based on
	// timeout duration.
	// However, if subsequent calls by different agents specify a different set of
	// `tasks` for the same `barrier_id`, the barrier will fail instantly.
	//
	// If no tasks are specified (default), the barrier will block for all the
	// connected tasks.
	//
	// Possible service errors:
	//   - DeadlineExceeded: Timed out waiting for specified tasks at the barrier.
	//     Deadline is determined by the server timestamp when it receives the
	//     first WaitAtBarrier() + timeout duration.
	//   - Cancelled: One of the tasks called CancelBarrier().
	//   - Aborted: Service is shutting down.
	//   - Internal: Any participating task is in ERROR state.
	//   - InvalidArgument: (1) Conflicting tasks specified by different agents
	//     for the same barrier, (2) one of the participating tasks is not in
	//     the cluster, or (3) task making the request is not included in the
	//     list of participating tasks.
	Barrier(context.Context, *BarrierRequest) (*BarrierResponse, error)
	// Aborts the barrier if it is ongoing.
	// Current and future WaitAtBarrier() calls with the same id will return a
	// CANCELLED error status.
	// Possible service errors:
	//   - FailedPrecondition: Barrier has already been passed.
	CancelBarrier(context.Context, *CancelBarrierRequest) (*CancelBarrierResponse, error)
	// contains filtered or unexported methods
}

type DeleteKeyValueRequest struct {
	Key         string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	IsDirectory bool   `protobuf:"varint,2,opt,name=is_directory,json=isDirectory,proto3" json:"is_directory,omitempty"`
	// contains filtered or unexported fields
}

type DeleteKeyValueResponse struct {
	// contains filtered or unexported fields
}

type DeviceInfo struct {
	Device []*anypb.Any `protobuf:"bytes,1,rep,name=device,proto3" json:"device,omitempty"`
	// contains filtered or unexported fields
}

type EntryValue struct {

	// Types that are assignable to Kind:
	//
	//	*EntryValue_DoubleValue
	//	*EntryValue_StringValue
	Kind isEntryValue_Kind `protobuf_oneof:"kind"`
	// contains filtered or unexported fields
}

type EntryValue_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,1,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

type EntryValue_StringValue struct {
	StringValue string `protobuf:"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type GPUInfo struct {
	Model string `protobuf:"bytes,1,opt,name=model,proto3" json:"model,omitempty"`              // e.g. "Tesla K40c"
	Uuid  string `protobuf:"bytes,2,opt,name=uuid,proto3" json:"uuid,omitempty"`                // Final entry in output of "nvidia-smi -L"
	BusId string `protobuf:"bytes,3,opt,name=bus_id,json=busId,proto3" json:"bus_id,omitempty"` // e.g. "0000:04:00.0"
	// contains filtered or unexported fields
}

type GetKeyValueDirRequest struct {
	DirectoryKey string `protobuf:"bytes,1,opt,name=directory_key,json=directoryKey,proto3" json:"directory_key,omitempty"`
	// contains filtered or unexported fields
}

type GetKeyValueDirResponse struct {
	DirectoryKey string           `protobuf:"bytes,1,opt,name=directory_key,json=directoryKey,proto3" json:"directory_key,omitempty"`
	Kv           []*KeyValueEntry `protobuf:"bytes,2,rep,name=kv,proto3" json:"kv,omitempty"`
	// contains filtered or unexported fields
}

type GetKeyValueRequest struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// contains filtered or unexported fields
}

type GetKeyValueResponse struct {
	Kv *KeyValueEntry `protobuf:"bytes,1,opt,name=kv,proto3" json:"kv,omitempty"`
	// contains filtered or unexported fields
}

type GetTaskStateRequest struct {
	SourceTask []*CoordinatedTask `protobuf:"bytes,1,rep,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type GetTaskStateResponse struct {
	TaskState []*CoordinatedTaskStateInfo `protobuf:"bytes,1,rep,name=task_state,json=taskState,proto3" json:"task_state,omitempty"`
	// contains filtered or unexported fields
}

type GrpcPayloadContainer struct {
	Payloads map[string][]byte `` /* 157-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GrpcPayloadsLost struct {
	// contains filtered or unexported fields
}

type HeartbeatRequest struct {
	Incarnation uint64           `protobuf:"fixed64,3,opt,name=incarnation,proto3" json:"incarnation,omitempty"`
	SourceTask  *CoordinatedTask `protobuf:"bytes,4,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type HeartbeatResponse struct {
	LeaderIncarnation uint64 `protobuf:"fixed64,1,opt,name=leader_incarnation,json=leaderIncarnation,proto3" json:"leader_incarnation,omitempty"`
	// contains filtered or unexported fields
}

type HistogramProto struct {
	Min        float64 `protobuf:"fixed64,1,opt,name=min,proto3" json:"min,omitempty"`
	Max        float64 `protobuf:"fixed64,2,opt,name=max,proto3" json:"max,omitempty"`
	Num        float64 `protobuf:"fixed64,3,opt,name=num,proto3" json:"num,omitempty"`
	Sum        float64 `protobuf:"fixed64,4,opt,name=sum,proto3" json:"sum,omitempty"`
	SumSquares float64 `protobuf:"fixed64,5,opt,name=sum_squares,json=sumSquares,proto3" json:"sum_squares,omitempty"`
	// Parallel arrays encoding the bucket boundaries and the bucket values.
	// bucket(i) is the count for the bucket i.  The range for
	// a bucket is:
	//
	//	i == 0:  -DBL_MAX .. bucket_limit(0)
	//	i != 0:  bucket_limit(i-1) .. bucket_limit(i)
	BucketLimit []float64 `protobuf:"fixed64,6,rep,packed,name=bucket_limit,json=bucketLimit,proto3" json:"bucket_limit,omitempty"`
	Bucket      []float64 `protobuf:"fixed64,7,rep,packed,name=bucket,proto3" json:"bucket,omitempty"`
	// contains filtered or unexported fields
}

type InsertKeyValueRequest struct {
	Kv *KeyValueEntry `protobuf:"bytes,1,opt,name=kv,proto3" json:"kv,omitempty"`
	// contains filtered or unexported fields
}

type InsertKeyValueResponse struct {
	// contains filtered or unexported fields
}

type KeyValueEntry struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type MachineConfiguration struct {

	// Host name of machine that ran the benchmark.
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// Unique serial number of the machine.
	SerialIdentifier string `protobuf:"bytes,7,opt,name=serial_identifier,json=serialIdentifier,proto3" json:"serial_identifier,omitempty"`
	// Additional platform information.
	PlatformInfo *PlatformInfo `protobuf:"bytes,2,opt,name=platform_info,json=platformInfo,proto3" json:"platform_info,omitempty"`
	// CPU Information.
	CpuInfo *CPUInfo `protobuf:"bytes,3,opt,name=cpu_info,json=cpuInfo,proto3" json:"cpu_info,omitempty"`
	// Other devices that are attached and relevant (e.g. GPUInfo).
	DeviceInfo []*anypb.Any `protobuf:"bytes,4,rep,name=device_info,json=deviceInfo,proto3" json:"device_info,omitempty"`
	// Devices accessible to the test (e.g. as given by list_local_devices).
	AvailableDeviceInfo []*AvailableDeviceInfo `protobuf:"bytes,5,rep,name=available_device_info,json=availableDeviceInfo,proto3" json:"available_device_info,omitempty"`
	MemoryInfo          *MemoryInfo            `protobuf:"bytes,6,opt,name=memory_info,json=memoryInfo,proto3" json:"memory_info,omitempty"`
	// contains filtered or unexported fields
}

type MemAllocatorStats struct {
	NumAllocs           int64   `protobuf:"varint,1,opt,name=num_allocs,json=numAllocs,proto3" json:"num_allocs,omitempty"`
	BytesInUse          int64   `protobuf:"varint,2,opt,name=bytes_in_use,json=bytesInUse,proto3" json:"bytes_in_use,omitempty"`
	PeakBytesInUse      int64   `protobuf:"varint,3,opt,name=peak_bytes_in_use,json=peakBytesInUse,proto3" json:"peak_bytes_in_use,omitempty"`
	LargestAllocSize    int64   `protobuf:"varint,4,opt,name=largest_alloc_size,json=largestAllocSize,proto3" json:"largest_alloc_size,omitempty"`
	FragmentationMetric float32 `protobuf:"fixed32,5,opt,name=fragmentation_metric,json=fragmentationMetric,proto3" json:"fragmentation_metric,omitempty"`
	// contains filtered or unexported fields
}

type MemChunk struct {
	Address       uint64 `protobuf:"varint,1,opt,name=address,proto3" json:"address,omitempty"`
	Size          int64  `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	RequestedSize int64  `protobuf:"varint,3,opt,name=requested_size,json=requestedSize,proto3" json:"requested_size,omitempty"`
	Bin           int32  `protobuf:"varint,4,opt,name=bin,proto3" json:"bin,omitempty"`
	OpName        string `protobuf:"bytes,5,opt,name=op_name,json=opName,proto3" json:"op_name,omitempty"`
	FreedAtCount  uint64 `protobuf:"varint,6,opt,name=freed_at_count,json=freedAtCount,proto3" json:"freed_at_count,omitempty"`
	ActionCount   uint64 `protobuf:"varint,7,opt,name=action_count,json=actionCount,proto3" json:"action_count,omitempty"`
	InUse         bool   `protobuf:"varint,8,opt,name=in_use,json=inUse,proto3" json:"in_use,omitempty"`
	StepId        uint64 `protobuf:"varint,9,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	// contains filtered or unexported fields
}

type MemoryDump struct {
	AllocatorName string             `protobuf:"bytes,1,opt,name=allocator_name,json=allocatorName,proto3" json:"allocator_name,omitempty"`
	BinSummary    []*BinSummary      `protobuf:"bytes,2,rep,name=bin_summary,json=binSummary,proto3" json:"bin_summary,omitempty"`
	Chunk         []*MemChunk        `protobuf:"bytes,3,rep,name=chunk,proto3" json:"chunk,omitempty"`
	SnapShot      []*SnapShot        `protobuf:"bytes,4,rep,name=snap_shot,json=snapShot,proto3" json:"snap_shot,omitempty"`
	Stats         *MemAllocatorStats `protobuf:"bytes,5,opt,name=stats,proto3" json:"stats,omitempty"`
	// contains filtered or unexported fields
}

type MemoryInfo struct {
	Total     int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`         // Total virtual memory in bytes
	Available int64 `protobuf:"varint,2,opt,name=available,proto3" json:"available,omitempty"` // Immediately available memory in bytes
	// contains filtered or unexported fields
}

type MetricEntry struct {

	// Metric name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Metric value
	Value float64 `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
	// The minimum acceptable value for the metric if specified
	MinValue *wrapperspb.DoubleValue `protobuf:"bytes,3,opt,name=min_value,json=minValue,proto3" json:"min_value,omitempty"`
	// The maximum acceptable value for the metric if specified
	MaxValue *wrapperspb.DoubleValue `protobuf:"bytes,4,opt,name=max_value,json=maxValue,proto3" json:"max_value,omitempty"`
	// contains filtered or unexported fields
}

type PlatformInfo struct {
	Bits    string `protobuf:"bytes,1,opt,name=bits,proto3" json:"bits,omitempty"`       // e.g. '64bit'
	Linkage string `protobuf:"bytes,2,opt,name=linkage,proto3" json:"linkage,omitempty"` // e.g. 'ELF'
	Machine string `protobuf:"bytes,3,opt,name=machine,proto3" json:"machine,omitempty"` // e.g. 'i386'
	Release string `protobuf:"bytes,4,opt,name=release,proto3" json:"release,omitempty"` // e.g. '3.13.0-76-generic'
	System  string `protobuf:"bytes,5,opt,name=system,proto3" json:"system,omitempty"`   // e.g. 'Linux'
	Version string `protobuf:"bytes,6,opt,name=version,proto3" json:"version,omitempty"` // e.g. '#120-Ubuntu SMP Mon Jan 18 15:59:10 UTC 2016'
	// contains filtered or unexported fields
}

type RPCOptions struct {

	// If true, always use RPC to contact the session target.
	//
	// If false (the default option), TensorFlow may use an optimized
	// transport for client-master communication that avoids the RPC
	// stack. This option is primarily for used testing the RPC stack.
	UseRpcForInprocessMaster bool `` /* 140-byte string literal not displayed */
	// The compression algorithm to be used. One of "deflate", "gzip".
	CompressionAlgorithm string `protobuf:"bytes,2,opt,name=compression_algorithm,json=compressionAlgorithm,proto3" json:"compression_algorithm,omitempty"`
	// If compression_algorithm is set, the compression level to be used.
	// From 0 (no compression), up to 3.
	CompressionLevel int32 `protobuf:"varint,3,opt,name=compression_level,json=compressionLevel,proto3" json:"compression_level,omitempty"`
	// Setting cache_rpc_response to true will enable sender side caching of
	// response for RecvTensorAsync and RecvBufAsync to allow receiver to retry
	// requests . This is only necessary when the network fabric is experiencing a
	// significant error rate.  Without it we'll fail a step on an network error,
	// while with it we'll be able to complete long steps (like complex
	// initializations) in the face of some network errors during RecvTensor.
	CacheRpcResponse bool `protobuf:"varint,4,opt,name=cache_rpc_response,json=cacheRpcResponse,proto3" json:"cache_rpc_response,omitempty"`
	// Disables TCP connection sharing when opening a new RPC channel.
	DisableSessionConnectionSharing bool `` /* 159-byte string literal not displayed */
	// Setting num_channels_per_target > 0 allows uses of multiple channels to
	// communicate to the same target. This can be used to improve the aggregate
	// throughput on high speed links (e.g 100G) where single connection is not
	// sufficient to maximize link utilization. Note that a single RPC only goes
	// on a single channel, this only helps in situations where there are multiple
	// transfers to the same target overlapping in time.
	NumChannelsPerTarget int32 `` /* 126-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RegisterTaskRequest struct {
	Incarnation uint64           `protobuf:"fixed64,3,opt,name=incarnation,proto3" json:"incarnation,omitempty"`
	SourceTask  *CoordinatedTask `protobuf:"bytes,5,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type RegisterTaskResponse struct {
	LeaderIncarnation uint64 `protobuf:"fixed64,1,opt,name=leader_incarnation,json=leaderIncarnation,proto3" json:"leader_incarnation,omitempty"`
	// contains filtered or unexported fields
}

type ReportErrorToServiceRequest struct {
	ErrorCode    int32            `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"`
	ErrorMessage string           `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	ErrorOrigin  *CoordinatedTask `protobuf:"bytes,5,opt,name=error_origin,json=errorOrigin,proto3" json:"error_origin,omitempty"`
	// contains filtered or unexported fields
}

type ReportErrorToServiceResponse struct {
	// contains filtered or unexported fields
}

type ReportErrorToTaskRequest struct {
	ErrorCode    int32                     `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"`
	ErrorMessage string                    `protobuf:"bytes,2,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	ErrorPayload *CoordinationServiceError `protobuf:"bytes,5,opt,name=error_payload,json=errorPayload,proto3" json:"error_payload,omitempty"`
	// contains filtered or unexported fields
}

type ReportErrorToTaskResponse struct {
	// contains filtered or unexported fields
}

type ResetTaskRequest struct {
	SourceTask *CoordinatedTask `protobuf:"bytes,1,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type ResetTaskResponse struct {
	// contains filtered or unexported fields
}

type RunConfiguration struct {
	Argument []string `protobuf:"bytes,1,rep,name=argument,proto3" json:"argument,omitempty"`
	// Environment variables used to run the test/benchmark.
	EnvVars map[string]string `` /* 170-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ShutdownTaskRequest struct {
	SourceTask *CoordinatedTask `protobuf:"bytes,1,opt,name=source_task,json=sourceTask,proto3" json:"source_task,omitempty"`
	// contains filtered or unexported fields
}

type ShutdownTaskResponse struct {
	// contains filtered or unexported fields
}

type SnapShot struct {
	ActionCount uint64 `protobuf:"varint,1,opt,name=action_count,json=actionCount,proto3" json:"action_count,omitempty"`
	Size        int64  `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// contains filtered or unexported fields
}

type StatusProto struct {

	// Status code as defined in tensorflow/tsl/protobuf/error_codes.proto.
	Code Code `protobuf:"varint,1,opt,name=code,proto3,enum=tensorflow.error.Code" json:"code,omitempty"`
	// Detail error message.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

type TestResults struct {

	// The target of the run, e.g.:
	//
	//	//tensorflow/core:kernels_adjust_contrast_op_benchmark_test
	Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// The list of tests or benchmarks in this run.
	Entries *BenchmarkEntries `protobuf:"bytes,2,opt,name=entries,proto3" json:"entries,omitempty"`
	// The configuration of the build (compiled opt? with cuda? any copts?)
	BuildConfiguration *BuildConfiguration `protobuf:"bytes,3,opt,name=build_configuration,json=buildConfiguration,proto3" json:"build_configuration,omitempty"`
	// The commit id (git hash or changelist)
	CommitId *CommitId `protobuf:"bytes,4,opt,name=commit_id,json=commitId,proto3" json:"commit_id,omitempty"`
	// The time the run started (in seconds of UTC time since Unix epoch)
	StartTime int64 `protobuf:"varint,5,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// The amount of time the total run took (wall time in seconds)
	RunTime float64 `protobuf:"fixed64,6,opt,name=run_time,json=runTime,proto3" json:"run_time,omitempty"`
	// Machine-specific parameters (Platform and CPU info)
	MachineConfiguration *MachineConfiguration `protobuf:"bytes,7,opt,name=machine_configuration,json=machineConfiguration,proto3" json:"machine_configuration,omitempty"`
	// Run-specific parameters (arguments, etc)
	RunConfiguration *RunConfiguration `protobuf:"bytes,8,opt,name=run_configuration,json=runConfiguration,proto3" json:"run_configuration,omitempty"`
	// Benchmark target identifier.
	Name          string                    `protobuf:"bytes,9,opt,name=name,proto3" json:"name,omitempty"`
	BenchmarkType TestResults_BenchmarkType `` /* 144-byte string literal not displayed */
	// Used for differentiating between continuous and debug builds.
	// Must be one of:
	// * cbuild: results from continuous build.
	// * presubmit: results from oneshot requests.
	// * culprit: results from culprit finder rerun.
	RunMode string `protobuf:"bytes,11,opt,name=run_mode,json=runMode,proto3" json:"run_mode,omitempty"`
	// TensorFlow version this benchmark runs against.
	// This can be either set to full version or just the major version.
	TfVersion string `protobuf:"bytes,12,opt,name=tf_version,json=tfVersion,proto3" json:"tf_version,omitempty"`
	// contains filtered or unexported fields
}