[[sec:parallel_execution]]
== Parallel projects

Gradle's parallel execution feature optimizes CPU utilization to accelerate builds by concurrently executing tasks from different projects.

    VersionNumber kotlinPluginVersion

    def "kotlin android on android-kotlin-example using #dsl DSL (kotlin=#kotlinPluginVersion, agp=#androidPluginVersion, workers=#parallel)"(String kotlinPluginVersion, String androidPluginVersion, boolean parallel) {
        given:
        AndroidHome.assertIsSet()
        AGP_VERSIONS.assumeAgpSupportsCurrentJavaVersionAndKotlinVersion(androidPluginVersion, kotlinPluginVersion)

	// We expect to see one "--- FAIL" line at the start
	// of the log, five lines of "parallel" logging,
	// and a final "FAIL" line at the end of the test.
	const wantLines = 7

	if len(lines) != wantLines {
		t.Fatalf("parallelTestHelper gave %d lines of output; want %d", len(lines), wantLines)
	}
	want := "helperfuncs_test.go:24: parallel"
	if got := strings.TrimSpace(lines[1]); got != want {

                            Thread.sleep(100)
                        }
                    }
                """
            }
        }
        expect:
        execute(buildA, "delegate", "--parallel", "--max-workers=$maxWorkers")
        operations.assertConcurrentOperationsDoNotExceed(ExecuteTaskBuildOperationType, maxWorkers, maxWorkers != 1)

        where:
        maxWorkers << [ 1, 2, 4 ]
    }

)
class NativeParallelPerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "clean assemble with parallel workers"() {
        given:
        runner.testGroup = 'parallel builds'
        runner.buildSpec {
            displayName("parallel")
            invocation {
                tasksToRun("clean", "assemble")
            }
        }
        runner.baseline {

	case "plan9":
		t.Skipf("not supported on %s", runtime.GOOS)
	}
	t.Parallel()

	for _, network := range []string{"tcp", "unix", "unixpacket"} {
		network := network
		t.Run(network, func(t *testing.T) {
			if !testableNetwork(network) {
				t.Skipf("network %s is not testable on the current platform", network)
			}
			t.Parallel()

			ln := newLocalListener(t, network)
			switch network {

        def generate = rootBuild.task('generate').dependsOn(generateBar).dependsOn(generateFoo)

        writeAllFiles()

        expect:
        2.times {
            args '--parallel', '--max-workers=2'
            succeeds(generate.path, clean.path)

            result.assertTaskOrder(generateFoo.fullPath, generateBar.fullPath, generate.fullPath)

        Set<Long> ids = new CopyOnWriteArraySet<Long>()

        5.times {
            parallel.start {
                100.times {
                    assertTrue(ids.add(generator.generateId()))
                }
            }
        }
        parallel.waitForAll()
    }

        when:
        succeeds(":resolve", "--parallel")

        then:
        outputContains("processing producer.jar using []")
        outputContains("processing consumer.jar using [producer.jar]")

        when:
        succeeds(":resolve", "--parallel")

        then:
        outputDoesNotContain("processing")

        when:
        succeeds(":resolve", "--parallel", "-DproducerContent=changed")

        then:

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>
<% if (binding.hasVariable("maxWorkers")) { %>org.gradle.workers.max=${binding.getVariable("maxWorkers")}<% } %>
compilerMemory=<% if (binding.hasVariable("compilerMemory")) { %>${binding.getVariable("compilerMemory")}<% } else { %>1g<% } %>