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 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 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 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 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 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 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 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 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
}

type TestResults_BenchmarkType int32

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