// specific algorithm (in this case, sorting) in parallel.
	testing.Benchmark(func(b *testing.B) {
		var compares atomic.Int64
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				s := []int{5, 4, 3, 2, 1}
				slices.SortFunc(s, func(a, b int) int {
					// Because RunParallel runs the function many
					// times in parallel, we must increment the
					// counter atomically to avoid racing writes.

                                                       TF_Status* status) const;

  // Construct a parallel tensor consisting of the scalar values from `values`.
  template <typename DataType>
  std::unique_ptr<ParallelTensor> ScalarsFromSequence(
      absl::Span<const DataType> values, TFE_Context* context,
      TF_Status* status) const;

  // A parallel tensor with scalar integers numbering component devices.

    // end of the pipeline. Mostly, it will rely on side effect analysis by
    // considering accessing resource only. However, for branches under parallel
    // group, there should not be any control deps between them even side effect
    // analysis indicate some control deps. Therefore, we will mark parallel
    // group and branch information here so that `UpdateControlDependenciesPass`
    // can fetch the related information later.

		t.Parallel()
		testMergeCombinePrograms(t, s)
	})
	t.Run("Dump", func(t *testing.T) {
		t.Parallel()
		testDump(t, s)
	})
	t.Run("Percent", func(t *testing.T) {
		t.Parallel()
		testPercent(t, s)
	})
	t.Run("PkgList", func(t *testing.T) {
		t.Parallel()
		testPkgList(t, s)
	})
	t.Run("Textfmt", func(t *testing.T) {
		t.Parallel()
		testTextfmt(t, s)
	})

        LOGGER.info("Using {} worker leases.", this.workerLimits.getMaxWorkerCount());
    }

    @Override
    public void startProjectExecution(boolean parallel) {
        Registries current = registries.get();
        Registries next = current.startProjectExecution(parallel);
        setProjectExecutionState(current, next);
    }

    @Override
    public void finishProjectExecution() {

class ParallelCompilerDaemonIntegrationTest extends AbstractIntegrationSpec {
    @Rule TestResources resources = new TestResources(temporaryFolder)

    def "daemon compiler can handle --parallel"() {
        generateProjects(10, 10, 10)

        args("--parallel")

        expect:
        succeeds("classes")
    }

    private generateProjects(int numProjects, int numJavaSources, int numGroovySources) {
        def settingsText = ""

 *
 * <ul>
 *     <li>Parallel execution of work items within a single task</li>
 *     <li>Execution in isolated contexts such as an isolated classloader or even a separate process</li>
 *     <li>Safe execution of multiple tasks in parallel</li>
 * </ul>
 *

org.gradle.caching=true
org.gradle.jvmargs='-Dfile.encoding=UTF-8'
org.gradle.parallel=true
android.enableJetifier=true
android.useAndroidX=true
kotlin.mpp.stability.nowarn=true
kotlin.js.compiler=ir
kotlin.incremental.js.ir=true
androidBuild=false
graalBuild=false
loomBuild=false
containerTests=false

 * and with intentionally unused source files in each source set. It currently uses a single
 * component per project so we can use parallel project execution. Generates headers, C and C++
 * files.
 *
 * "monolithic" here means the project follows a monorepo layout. If we used intra-parallel
 * execution, this might be built as a single project with many components instead.
 *

   * an edge connecting node A to node B if this {@link Network} has an edge connecting A to B.
   *
   * <p>If this network {@link #allowsParallelEdges() allows parallel edges}, parallel edges will be
   * treated as if collapsed into a single edge. For example, the {@link #degree(Object)} of a node
   * in the {@link Graph} view may be less than the degree of the same node in this {@link Network}.
   */