func (c Config) GetDestination() Destination {
	if len(c.Rules) > 0 {
		return c.Rules[0].Destination
	}
	return Destination{}
}

// Replicate returns true if the object should be replicated.
func (c Config) Replicate(obj ObjectOpts) bool {
	for _, rule := range c.FilterActionableRules(obj) {
		if rule.Status == Disabled {
			continue
		}

  // operand is a replicate resource block argument, replace ShapeOp with
  // VariableShapeOp and use the associated first replica operand as its
  // operand.
  auto read_var_op = llvm::dyn_cast<TF::ReadVariableOp>(input_def);
  if (!read_var_op) return;

  // TODO(lyandy): Check if resource (first replica or replicate block arg)
  // shape has not changed in replicate prior to read. Currently after both

func.func @testReadVariableOpColocated(%arg0: tensor<*x!tf_type.resource<tensor<4xf32>>>) {
  // CHECK:      tf_device.replicate
  // CHECK-SAME: (%[[ARG0]] as %[[RI_0:[a-z0-9]*]]: tensor<*x!tf_type.resource<tensor<4xf32>>>)
  tf_device.replicate(%arg0 as %arg1: tensor<*x!tf_type.resource<tensor<4xf32>>>) {
    _mirrored_variable_indices = [0],

// CHECK-LABEL: func @empty_replicate
func.func @empty_replicate() {
  tf_device.replicate {n = 2 : i32} {
  }
  func.return

// CHECK:      tf_device.replicate
// CHECK-SAME: n = 2
// CHECK-NEXT:   tf_device.return
}

// -----

// CHECK-LABEL: func @no_operand_replicate
func.func @no_operand_replicate() {
  tf_device.replicate {n = 2 : i32} {
    %0 = "tf.Const"() { value = dense<0> : tensor<i64> } : () -> tensor<i64>

  // CHECK:      %[[READ:.*]] = "tf.ReadVariableOp"
  // CHECK-NEXT: tf_device.replicate
  // CHECK-NEXT:   "tf.OpA"(%[[READ]])
  tf_device.replicate {n = 2 : i32} {
    %0 = "tf.ReadVariableOp"(%arg0) : (tensor<*x!tf_type.resource<tensor<f32>>>) -> tensor<f32>
    "tf.OpA"(%0) : (tensor<f32>) -> ()
  }
  func.return
}

// -----

// Tests per replica island has same control operands as island holding
// replicate.
// CHECK-LABEL: func @controls_per_replica
func.func @controls_per_replica() {
  tf_executor.graph {
    %1 = tf_executor.ControlTrigger {}
    %2 = tf_executor.ControlTrigger {}
    %3 = tf_executor.island(%1, %2) {
      tf_device.replicate {n = 2 : i32} {

      execute_launches.push_back(op);
  });

  OpBuilder builder(&getContext());
  for (auto execute_launch : execute_launches) {
    auto replicate = execute_launch->getParentOfType<tf_device::ReplicateOp>();
    if (!replicate) continue;

    ColocateCompositeResourceOpsInReplicate(replicate, &builder);
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateTPUColocateCompositeResourceOps() {

void HoistBroadcastRead::runOnOperation() {
  FuncOp func = getOperation();

  auto result = func.walk([&](ReplicateOp replicate) {
    llvm::SmallVector<ReadVariableOp, 4> reads;
    if (failed(GetReads(func, replicate, reads)))
      return WalkResult::interrupt();
    MoveReads(replicate, reads);
    return WalkResult::advance();
  });

  if (result.wasInterrupted()) return signalPassFailure();
}

bool IsOtherReplicatedSharding(const xla::OpSharding& xla_sharding);

// Returns whether the sharding is split sharding. i.e. A sharding with OTHER
// type but not replicated.
bool IsSplitSharding(const xla::OpSharding& sharding);

// Returns whether the sharding is replicated. It includes sharding with
// REPLICATED type and replicated OTHER type.

//   Executor Dialect or TF Functional Dialect. Will convert to TF Functional.
//   is_supported_by_replicated_brige - If the graph targets the replicated
//   bridge. Set it to true for replicated/partitioned graphs. e.g. replicated
//   and single-core TPU graphs. Set this to false if the graph is not
//   replicated, e.g. CPU/GPU graphs. is_in_fallback_enabled_mode - Whether this
//   was called with fallback to the non-MLIR Bridge. This is just for logging