import org.gradle.internal.service.scopes.ServiceScope;

/**
 * A bunch of information about the request that launched the current build.
 */
@ServiceScope(Scope.BuildSession.class)
public interface BuildRequestMetaData {

    /**
     * Returns the meta-data about the client used to launch this build.
     */
    BuildClientMetaData getClient();

    /**

  }];
}

def AsyncOp: Mlrt_Op<"async", []> {
  let summary = "Launches a function asynchronously.";

  let description = [{
    Launch a function asynchronously.

    $args: a list of arguments to be passed.
    $callee: The function to be launched. Its return op must not have operands.

    $handle: This op returns a handle object that manages the context of the async execution.

    mlir::tf_device::ParallelExecuteOp old_parallel_execute,
    mlir::tf_device::ParallelExecuteOp* new_parallel_execute);

// Wraps single op in `tf_device.launch` for explicit device assignment.
mlir::tf_device::LaunchOp WrapOpInLaunch(mlir::OpBuilder* builder,
                                         mlir::Location loc,
                                         mlir::Operation* op,

 */

package org.gradle.launcher.daemon

import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.integtests.fixtures.daemon.DaemonContextParser
import org.gradle.integtests.fixtures.daemon.DaemonIntegrationSpec
import org.gradle.integtests.fixtures.daemon.DaemonLogsAnalyzer
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.launcher.daemon.context.DaemonContext

    if (IsDeviceClusterOp(*op) && HasChildLaunchDeviceOp(*op)) {
      std::string launch_error =
          absl::StrCat("Node `", op->getName().getStringRef().str(), "` ",
                       "is a launch op which should have been removed by "
                       "outside compilation");

      op->emitError() << launch_error;
      LOG(ERROR) << launch_error;
      return WalkResult::interrupt();
    }

     * If the debugger is not present then the test execution will fail.
     * <p>
     * Invoking this method adjusts the test task to launch only one JVM. More specifically, the parallel execution
     * gets disabled and the {@code forkEvery} property is set to 0.
     *
     * @param port the target port where the test JVM expects the debugger

func (b *B) run() BenchmarkResult {
	go b.launch()
	<-b.signal
	return b.result
}

// launch launches the benchmark function. It gradually increases the number
// of benchmark iterations until the benchmark runs for a second in order
// to get a reasonable measurement. It prints timing information in this form
//		testing.BenchmarkHello	100000		19 ns/op
// launch is run by the fun function as a separate goroutine.

  mlir::OpBuilder builder(&context);
  auto loc = cluster->getLoc();

  // Wrap the cluster op into a Launch op
  auto launch_op = tensorflow::WrapOpInLaunch(&builder, loc, cluster, device);

  EXPECT_TRUE(llvm::isa<mlir::tf_device::LaunchOp>(launch_op));
  launch_op->erase();
}

}  // namespace

    var firstException: IOException? = null
    try {
      while (tcpConnectsInFlight.isNotEmpty() || routePlanner.hasNext()) {
        if (routePlanner.isCanceled()) throw IOException("Canceled")

        // Launch a new connection if we're ready to.
        val now = taskRunner.backend.nanoTime()
        var awaitTimeoutNanos = nextTcpConnectAtNanos - now
        var connectResult: ConnectResult? = null

// Test that extract TPUCopyWithDynamicShape from host launch to device launch.

module attributes {tf.devices = {"/job:localhost/replica:0/task:0/device:COMPOSITE:0", "/job:localhost/replica:0/task:0/device:CPU:0", "/job:localhost/replica:0/task:0/device:TPU:0", "/job:localhost/replica:0/task:0/device:TPU_SYSTEM:0"}} {
  // CHECK-LABEL: func @valid_copy_op_in_replicated_host

  // CHECK: "tf_device.launch"
  // CHECK-SAME: "TPU_REPLICATED_HOST_0"