namespace {

using ::stablehlo::quantization::Method;
using ::stablehlo::quantization::QuantizedType;
using ::stablehlo::quantization::WeightOnlyPtq;

// Inserts quantization parameters of weights for weight-only quantization and
// dynamic range quantization of `stablehlo.convolution` and
// `stablehlo.dot_general`.
class InsertWeightParamPass
    : public impl::InsertWeightParamPassBase<InsertWeightParamPass> {
 public:

      }
    }
  }
}
node {
  name: "MobilenetV1/Conv2d_0/weights/read"
  op: "Identity"
  input: "MobilenetV1/Conv2d_0/weights"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "_class"
    value {
      list {
        s: "loc:@MobilenetV1/Conv2d_0/weights"
      }
    }
  }
}
node {
  name: "MobilenetV1/MobilenetV1/Conv2d_0/Conv2D"

area: traffic-management

releaseNotes:
  - |
    **Updated** Istio's default load balancing algorithm from `ROUND_ROBIN` to `LEAST_REQUEST`.
    The `ROUND_ROBIN` algorithm can lead to overburdened endpoints, especially when weights
    are used. The `LEAST_REQUEST` algorithm, distributes more evenly across and is far less
    likely to overburden endpoints. A number of experiments (by both the Istio and

      "composite_conv.*");

  // Enable per-channel quantization for convolution weights.
  QuantizedType conv_weight_quantized_type{};

  // Assumes NHWC format, specifying the channel dimension (3) as the
  // quantized axis.
  conv_weight_quantized_type.mutable_dimension_specs()->set_dimension(3);

  // The index of weight operands passed to lifted functions for convolution
  // is 1.

  value {
    file_line_cols {
      file_index: 49
      line: 492
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/weights@"
  value {
    file_line_cols {
      file_index: 54
      line: 649
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/weights/read@"
  value {
    file_line_cols {
      file_index: 49
      line: 421
    }
  }
}
traces {

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package metrics

// Float64Histogram represents a distribution of float64 values.
type Float64Histogram struct {
	// Counts contains the weights for each histogram bucket.
	//
	// Given N buckets, Count[n] is the weight of the range
	// [bucket[n], bucket[n+1]), for 0 <= n < N.
	Counts []uint64

    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-quantize-weights";
  }

  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Quantize weights used by quantizable ops.";
  }

  void getDependentDialects(DialectRegistry& registry) const override {

  value {
    file_line_cols {
      file_index: 49
      line: 492
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/weights@"
  value {
    file_line_cols {
      file_index: 54
      line: 649
    }
  }
}
traces {
  key: "MobilenetV1/Conv2d_0/weights/read@"
  value {
    file_line_cols {
      file_index: 49
      line: 421
    }
  }
}
traces {

  // For now, restrict scale adjustment to ops with affine quantized weights,
  // and having weights and biases as constants. This currently only applies to
  // FC and Conv* ops. Restriction for the weight can be relaxed if there are
  // needs for adjusting scale of variable weights.
  auto affine_op = dyn_cast<AffineQuantizedOpInterface>(op);

	if forwardTo == nil {
		return nil, nil, nil
	}

	weights := []int{}
	action := []k8s.BackendRef{}
	for _, w := range forwardTo {
		wt := int(ptr.OrDefault(w.Weight, 1))
		if wt == 0 {
			continue
		}
		action = append(action, w)
		weights = append(weights, wt)
	}
	if len(weights) == 1 {
		weights = []int{0}
	}

	var invalidBackendErr *ConfigError