template <typename... LabelType>
int64_t TFE_MonitoringCounterReader::Read(const LabelType&... labels) {
  return counter->Read(labels...);
}

TFE_MonitoringCounterReader* TFE_MonitoringNewCounterReader(const char* name) {
  auto* result = new TFE_MonitoringCounterReader(name);

  return result;
}

int64_t TFE_MonitoringReadCounter0(TFE_MonitoringCounterReader* cell_reader) {
  int64_t result = cell_reader->Read();

  // `auto_control_deps.py` where it is assumed that allocated resource values
  // NEVER alias. We should align our assumptions in the future.
  static constexpr int64_t kUnknownResourceId = -1;
  static constexpr int64_t kInvalidResourceId = -2;
  static constexpr int64_t kMaxResourceTypeId = 9999;
};

}  // namespace detail

// An analysis that runs on a module and maps each resource-type value to a

    return absl::OkStatus();
  }
  Status SetAttrShape(const char* attr_name, const int64_t* dims,
                      const int num_dims) override {
    PartialTensorShape shape;
    if (num_dims >= 0) {
      shape = PartialTensorShape(ArraySlice<int64_t>(
          reinterpret_cast<const int64_t*>(dims), num_dims));
    }
    op_->node_builder.Attr(attr_name, shape);
    return absl::OkStatus();
  }

  EXPECT_THAT(num_bytes, Eq(16));
}

TEST_F(GetSizeInBytesTest, Bfloat16ConstOpSizeInBytes) {
  constexpr absl::string_view kConstOpExpr = R"mlir(
    %cst = "tf.Const"() {value = dense<1.0> : tensor<7xbf16>} : () -> tensor<7xbf16>
  )mlir";

  Block block{};
  TF::ConstOp int_tensor_const_op = ParseConstOp(kConstOpExpr, block, ctx_);

      // back the result to get the same shape as the original operand.

      SmallVector<int64_t, 4> permutation_array;
      for (int64_t i = 0; i < scatter_dims_to_operand_dims.size(); ++i) {
        permutation_array.push_back(scatter_dims_to_operand_dims[i]);
      }
      for (int64_t i = 0; i < operand_type.getRank(); ++i) {
        if (!llvm::is_contained(scatter_dims_to_operand_dims, i)) {

TFE_MonitoringCounter1* CreateCounter1(const char* counter_name,
                                       const char* label);
void IncrementCounter0(TFE_MonitoringCounter0* counter, int64_t delta = 1);
void IncrementCounter1(TFE_MonitoringCounter1* counter, const char* label,
                       int64_t delta = 1);

TEST(CAPI, MonitoringCellReader0) {
  auto counter_name = "test/counter0";
  auto* counter = CreateCounter0(counter_name);

      %4 = mhlo.multiply %3, %3 : tensor<?xi32>
      return %4 : tensor<?xi32>
    }
  })";
  CellReader<int64_t> legal_error(kFailedLegalizationStreamz);
  CellReader<int64_t> static_error(kNonStaticOpStreamz);
  CreateModule(kNonStaticFailure);

  auto result = Run();

  EXPECT_TRUE(result.failed());

  explicit TFE_MonitoringCounterReader(const char* name) {
    counter = std::make_unique<
        ::tensorflow::monitoring::testing::CellReader<int64_t>>(name);
  }
  template <typename... LabelType>
  int64_t Read(const LabelType&... labels);
  std::unique_ptr<::tensorflow::monitoring::testing::CellReader<int64_t>>
      counter;
};

  struct ClusterCompileStats {
    // Number of times the cluster has been (re-)compiled.
    int64_t compile_count = 0;

    // The number of times this cluster has been executed.
    int64_t execution_count = 0;

    // Cumulative time spent compiling the cluster.
    int64_t cumulative_compile_time_us = 0;

    // True if we have decided that this cluster is too dynamic (i.e. its shapes

    const DenseIntElementsAttr& dense_attr, PatternRewriter& builder) {
  std::vector<int32_t> ret(dense_attr.getNumElements());
  auto range = dense_attr.getValues<int64_t>();
  std::transform(range.begin(), range.end(), ret.begin(),
                 [](int64_t attr) { return static_cast<int32_t>(attr); });
  return DenseIntElementsAttr::get(
      RankedTensorType::get(ret.size(), builder.getIntegerType(32)), ret);
}