const auto single_map,
        io::ReadBinaryProto<CalibrationStatisticsMap>(
            tsl::io::JoinPath(calibration_data_dir, statistics_file)));
    statistics_map.insert(single_map.statistics().begin(),
                          single_map.statistics().end());
  }
  return statistics_map;
}

absl::Status AddCalibrationStatistics(
    mlir::ModuleOp module_op, absl::string_view calibration_data_dir,

#include "tensorflow/compiler/mlir/quantization/tensorflow/python/py_function_lib.h"

namespace stablehlo::quantization {

// Reads the calibration statistics from the given directory.
absl::StatusOr<absl::flat_hash_map<
    std::string, tensorflow::calibrator::CalibrationStatistics>>
ReadStatistics(absl::string_view calibration_data_dir);

    }

    private static boolean retainedFiles(Map<String, ?> result) {
        def statistics = result.statistics
        statistics.retainedRegularFiles > 0 ||
            statistics.retainedDirectories > 0 ||
            statistics.retainedMissingFiles > 0
    }

    )
    statistics = calib_stats_pb2.CalibrationStatistics()
    statistics.average_min_max_statistics.min_sum = 5.0
    statistics.average_min_max_statistics.max_sum = 50.0
    statistics.average_min_max_statistics.num_samples = 5

    min_value, max_value = calibration_algorithm.get_min_max_value(
        statistics, calib_opts
    )

            boolean printedDetail = formatDetail(textOutput, statistics.getExecutedTasksCount(), "executed", false);
            printedDetail = formatDetail(textOutput, statistics.getFromCacheTaskCount(), "from cache", printedDetail);
            formatDetail(textOutput, statistics.getUpToDateTaskCount(), "up-to-date", printedDetail);
            textOutput.println();
        }
    }

      std::optional<CalibrationStatistics> statistics =
          collector->GetStatistics();
      if (!statistics.has_value()) continue;

      statistics_map.mutable_statistics()->emplace(id, std::move(*statistics));
    }

    if (auto status = output_file_->Append(statistics_map.SerializeAsString());
        !status.ok()) {
      LOG(ERROR) << "Failed to write calibration statistics: "
                 << status.message();

cc_library(
    name = "min_max_value",
    srcs = [],
    hdrs = ["min_max_value.h"],
    compatible_with = get_compatible_with_portable(),
    deps = [],
)

cc_library(
    name = "statistics",
    srcs = ["statistics.cc"],
    hdrs = ["statistics.h"],
    compatible_with = get_compatible_with_portable(),
    deps = [
        "//tensorflow/compiler/mlir/quantization/stablehlo:quantization_config_proto_cc",

CalibrationStatisticsCollectorAverageMinMax::GetStatistics() const {
  if (average_min_max_statistics_.num_samples() == 0) return std::nullopt;

  CalibrationStatistics statistics;
  statistics.mutable_average_min_max_statistics()->CopyFrom(
      average_min_max_statistics_);

  return statistics;
}

}  // namespace calibrator

  HistogramStatistics histogram_statistics = 3;
}

message CalibrationStatisticsMap {
  // A map from the id of CustomAggregator op to its collected statistics.
  map<string, CalibrationStatistics> statistics = 1;

#include <cstdint>
#include <string>

#include "tensorflow/compiler/jit/xla_compile_util.h"
#include "tensorflow/core/framework/attr_value.pb.h"

namespace tensorflow {

// Tracks statistics for device compilation and uses these to determine whether
// the given cluster should be compiled or not.
class DeviceCompilationProfiler : public ResourceBase {
 public:
  DeviceCompilationProfiler() = default;