absl::Span<const XlaArgument> args,
                                     XlaCompilationResult* result) {
  return ADD_SOURCE_LOCATION(
      xla_compiler_.CompileFunction(options, function, args, result));
}

Status TfGraphToHloCompiler::CompileSingleOp(
    const XlaCompiler::CompileOptions& options, const OpKernelContext* ctx,
    absl::Span<const XlaArgument> args, XlaCompilationResult* result) {

 *
 * See LoggingBuildOperationProgressBroadcaster.
 *
 * @since 7.4
 */
public interface StyledTextBuildOperationProgressDetails {

    List<? extends Span> getSpans();

    String getCategory();

    LogEventLevel getLevel();

    interface Span {

        /**
         * Always a value name of {@code org.gradle.internal.logging.text.StyledTextOutput.Style}.
         */
        String getStyleName();

#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/test.h"

namespace tensorflow {
namespace {

Status PickDeviceHelper(bool allow_mixing_unknown_and_cpu,
                        absl::Span<const absl::string_view> device_names,
                        string* result) {
  jit::DeviceInfoCache cache;
  jit::DeviceSet device_set;
  for (absl::string_view name : device_names) {

	arch string
	name string
}

var (
	bases   = map[baseKey]v1.Image{}
	basesMu sync.RWMutex
)

func WarmBase(ctx context.Context, architectures []string, baseImages ...string) {
	_, span := tracing.Start(ctx, "RunCrane")
	defer span.End()
	basesMu.Lock()
	wg := sync.WaitGroup{}
	wg.Add(len(baseImages) * len(architectures))
	resolvedBaseImages := make([]v1.Image, len(baseImages)*len(architectures))
	keys := []baseKey{}

  // XlaCompilationResult pointed to by `result` by calling
  // XlaCompiler::CompileFunction.
  Status Compile(const XlaCompiler::CompileOptions& options,
                 const NameAttrList& function,
                 absl::Span<const XlaArgument> args,
                 XlaCompilationResult* result) override;

  // Compiles a Tensorflow single op into an HloModuleProto stored in the
  // XlaCompilationResult pointed to by `result` by calling

Status SetAttrFunctionList(AbstractOperation*, const char* attr_name,
                           absl::Span<const AbstractOperation*> values,
                           ForwardOperation*);

// Make the call to `Tape::RecordOperation`.
Status Execute(AbstractOperation*, AbstractContext*,
               absl::Span<AbstractTensorHandle*> retvals, int* num_retvals,
               ForwardOperation*, Tape*, const GradientRegistry&);

																	<span class="badge bg-primary"><la:message
                                                                            key="labels.enabled"/></span>
                                                    </c:if> <c:if test="${data.available=='false'}">
																	<span class="badge bg-gray"><la:message

			})
		}
		ret = append(ret, Trace{Spans: spans})
	}
	if len(ret) > 0 {
		return ret, nil
	}
	return []Trace{}, errors.New("cannot find any traces")
}

func buildSpan(obj any) Span {
	var s Span
	spanSpec := obj.(map[string]any)
	if spanID, ok := spanSpec["id"]; ok {
		s.SpanID = spanID.(string)
	}
	if parentSpanID, ok := spanSpec["parentId"]; ok {
		s.ParentSpanID = parentSpanID.(string)
	}

#include <string>
#include <utility>

#include "absl/container/flat_hash_map.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/types/span.h"
#include "tensorflow/compiler/mlir/quantization/stablehlo/quantization_config.pb.h"
#include "tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.pb.h"

namespace stablehlo::quantization {

#include "tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics_collector_min_max.h"

#include <algorithm>
#include <cstdint>
#include <limits>
#include <optional>

#include "absl/types/span.h"
#include "tensorflow/compiler/mlir/quantization/tensorflow/calibrator/calibration_statistics.pb.h"

namespace tensorflow {
namespace calibrator {

void CalibrationStatisticsCollectorMinMax::ClearData() {