go func() {
		for {
			rb.Read(buf)
		}
	}()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		rb.Write(data)
	}
}

func BenchmarkRingBuffer_AsyncReadBlocking(b *testing.B) {
	const sz = 512
	const buffers = 10
	rb := New(sz * buffers)
	rb.SetBlocking(true)
	data := []byte(strings.Repeat("a", sz))
	buf := make([]byte, sz)

	go func() {
		for {
			rb.Read(buf)
		}
	}()

          ids_[idx], static_cast<CalibrationMethod>(calibration_methods_[idx]));

      const Tensor& min_tensor = context->input(3 * idx);
      const Tensor& max_tensor = context->input(3 * idx + 1);
      const Tensor& histogram_tensor = context->input(3 * idx + 2);

      const float min_value = min_tensor.scalar<float>()();
      const float max_value = max_tensor.scalar<float>()();

  const tflite::TensorType inference_tensor_type =
      FromTocoDataTypeToTflitToTensorType(inference_type);
  const tflite::TensorType input_type =
      FromTocoDataTypeToTflitToTensorType(input_data_type);
  const tflite::TensorType output_type =
      FromTocoDataTypeToTflitToTensorType(output_data_type);

  std::string output_model;
  const absl::string_view input_model_buffer(buf, length);

  return new_config;
}

bool HasQuantizationMethod(const QuantizationSpecs& specs,
                           Method::MethodCase method_case) {
  for (const auto& spec : specs.specs()) {
    if (spec.method().method_case() == method_case) {
      return true;
    }
  }
  return false;
}

QuantizationConfig PopulateDefaults(
    const QuantizationConfig& user_provided_config) {

// attribute of `Placeholder` op.
Status InferShapes(Graph* graph, const std::map<int, InferredShape>& arg_shapes,
                   const tensorflow::FunctionLibraryDefinition* fnlib_def,
                   GraphShapeInfo* shape_info);

// Merges two InferredShapes. Return an error if the two shapes cannot be
// merged.
absl::StatusOr<InferredShape> MergeInferredShapes(const InferredShape& a,

// from a saved model or from an mlir file.
absl::StatusOr<quant::stablehlo::ImportedMlirModuleOp> ImportSavedModelOrTfMlir(
    absl::string_view input_path, MLIRContext* context,
    const std::vector<std::string>& exported_model_signatures,
    const std::vector<std::string>& tag_names, bool is_input_mlir_module) {
  if (is_input_mlir_module) {
    std::string error_message;
    std::unique_ptr<llvm::MemoryBuffer> file =

#include "tensorflow/core/lib/strings/str_util.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

template <typename R>
void UpdateTensorListResultTypesForIf(
    const llvm::SmallSet<int, 4> &tensor_list_index,
    const llvm::SmallSet<int, 4> &resized_tensor_list_index,
    const llvm::DenseMap<int, int> &tensor_list_map, ArrayRef<Type> types,
    R &&range, ValueRange operands,
    llvm::SmallVectorImpl<Type> *updated_types) {
  int i = 0;
  for (const auto it : llvm::zip(types, range)) {
    if (!tensor_list_index.count(i)) {

	"go/parser"
	"go/token"
	"internal/diff"
	"io"
	"os"
	"path/filepath"
	"testing"
	"time"
)

const (
	dataDir  = "testdata"
	tabwidth = 8
)

var update = flag.Bool("update", false, "update golden files")

var fset = token.NewFileSet()

type checkMode uint

const (
	export checkMode = 1 << iota
	rawFormat
	normNumber
	idempotent
	allowTypeParams
)

func.func @while_test() -> (tensor<i32>) {
  // CHECK: [[CONST:%.*]] = tfrt_fallback_async.const_dense_tensor dense<0> : tensor<i32>
  %0 = "tf.Const"() {device = "/device:CPU:0", value = dense<0> : tensor<i32>} : () -> tensor<i32>
  // CHECK: [[pred_res:%.*]]:2 = tfrt.call @"while_cond_lt9/tfrt_predicate"([[ARG0]], [[CONST]]) : (!tfrt.chain, !tfrt_fallback.tf_tensor) -> (!tfrt.chain, i1)