struct KernelSpec {
  // Scale constraint
  ScaleConstraintType type;

  // Custom function to derive the scales. Only available when the scale
  // constraint is `CustomScale`.
  ScaleFn scale_fn;
};

class KernelSpecs {
 public:
  using Signature = llvm::SmallVector<quant::AnyQuantizedType, 4>;

  // Returns the kernel specification for the kernel signature.

  switch (spec->type) {
    case ScaleConstraintType::OutputInputFreeScale: {
      // no propagation.
      *changed |= false;
      break;
    }
    case ScaleConstraintType::CustomScale: {
      if (failed(spec->scale_fn(this, op, new_items, changed))) {
        return failure();
      }
      break;
    }
    case ScaleConstraintType::OutputInputSameScale: {
      auto params = GetQuantParamsForSameScaleConstraint(op);

Dr. Stefan Schimanski <******@****.***> 1485349987 +0100

		&metrics.CounterOpts{
			Subsystem:      hpaControllerSubsystem,
			Name:           "reconciliations_total",
			Help:           "Number of reconciliations of HPA controller. The label 'action' should be either 'scale_down', 'scale_up', or 'none'. Also, the label 'error' should be either 'spec', 'internal', or 'none'. Note that if both spec and internal errors happen during a reconciliation, the first one to occur is reported in `error` label.",

  Value scale_op = rewriter.create<TF::ConstOp>(
      loc, scale_type,
      DenseFPElementsAttr::get(scale_type,
                               {static_cast<float>(qtype.getScale())}));

  if (original_input_tensor_type.getElementType().isBF16()) {
    // Add bf16 cast op after scale to match with the next op's data
    // type.
    scale_op = rewriter.create<TF::CastOp>(

      return quantizeF32ToInt8(expressed_value);
    }

    bool lossy;
    expressed_value.convert(scale_.getSemantics(), round_mode_, &lossy);
    // fixed_point = clamp(clamp_min, clamp_max, (
    //   roundHalfToEven(expressed / scale) + zero_point))
    APFloat scaled = (expressed_value / scale_);
    scaled.roundToIntegral(round_mode_);
    scaled.add(zero_point_, round_mode_);

    %scale_f64 = "tf.Div"(%range_nume, %range_deno) : (tensor<1xf64>, tensor<f64>) -> tensor<1xf64>
    %scale = "tf.Cast"(%scale_f64) : (tensor<1xf64>) -> tensor<1xf32>

    // Add comparison with minimum if needed
    %intermediate_val = "tf.Div"(%r_max_f64, %scale_f64) : (tensor<1xf64>, tensor<1xf64>) -> tensor<1xf64>

*/

package monitor

import (
	"time"

	v2 "k8s.io/api/autoscaling/v2"
)

type ActionLabel string
type ErrorLabel string

const (
	ActionLabelScaleUp   ActionLabel = "scale_up"
	ActionLabelScaleDown ActionLabel = "scale_down"
	ActionLabelNone      ActionLabel = "none"

	// ErrorLabelSpec represents an error due to an invalid spec of HPA object.
	ErrorLabelSpec ErrorLabel = "spec"

      return failure();
    }

    TF::ConstOp scale_op;
    TF::ConstOp zp_op;

    // Reads quantization parameters from the quantized type, and converts
    // them to constants.
    rewriter.setInsertionPoint(qparams_op);
    Location loc = qparams_op->getLoc();
    if (auto qtype = cast_qtype.dyn_cast<quant::UniformQuantizedType>()) {
      scale_op = rewriter.create<TF::ConstOp>(

  } else {  // float
    signature->push_back(AnyQuantizedType());
  }
}

LogicalResult DeviceTarget::RegisterKernel(
    llvm::StringRef kernel, const KernelSpecs::Signature& signature,
    const ScaleFn& fn, const ScaleDecomposeFn& dfn) {
  return specs_[kernel].Add(signature, {ScaleConstraintType::CustomScale, fn});
}

namespace ph = std::placeholders;

LogicalResult DeviceTarget::RegisterKernel(