#include "tensorflow/compiler/mlir/tensorflow/ir/tf_executor.h"

namespace mlir {
namespace TF {

// Converts a single island into multiple islands (one for each op).
void SplitIsland(mlir::tf_executor::IslandOp island_op,
                 mlir::tf_executor::ControlType control_type);

}  // namespace TF
}  // namespace mlir

  island_op.getControl().dropAllUses();

  // Break up all islands by simply creating a new island wrapping each
  // individual sub op. Do not create any control dependencies between the
  // newly created islands.
  SplitIsland(island_op, tf_executor::ControlType::get(&getContext()));

  // None of the originally given control deps are necessary.
  tf_executor::FetchOp fetch_op = graph_op.GetFetch();
  int num_control_fetches =

    auto control_type =
        mlir::tf_executor::ControlType::get(tf_dialect->getContext());
    getOperation().walk(
        [&control_type](mlir::tf_executor::IslandOp curr_island) {
          mlir::TF::SplitIsland(curr_island, control_type);
        });
  }
}

}  // anonymous namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateLaunchToDeviceAttributePass(
    bool legacy_graph_export) {

    auto control_type = tf_executor::ControlType::get(island_op.getContext());
    for (auto& execute : executes) {
      if (execute.GetBody().getOperations().size() > 1) {
        mlir::TF::SplitIsland(execute, control_type);
      }
    }
  }

  island_op.erase();
}

void ParallelExecuteToIslandsPass::runOnOperation() {
  // Find islands with a single `tf_device.parallel_execute` and create

    auto control_type = tf_executor::ControlType::get(island_op.getContext());
    for (auto& replica : replicas) {
      if (replica.GetBody().getOperations().size() > 1) {
        mlir::TF::SplitIsland(replica, control_type);
      }
    }
  }

  island_op.erase();
  return success();
}

void ReplicateToIslandPass::runOnOperation() {