diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/CompilationDatabase.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/CompilationDatabase.kt index 388d6832f83..713c4b21bdd 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/CompilationDatabase.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/CompilationDatabase.kt @@ -18,7 +18,6 @@ import org.gradle.api.tasks.Internal import org.gradle.api.tasks.OutputFile import org.gradle.api.tasks.TaskAction import org.gradle.kotlin.dsl.getByType -import org.jetbrains.kotlin.bitcode.CompileToBitcode import java.io.FileReader import java.io.FileWriter @@ -111,28 +110,3 @@ fun mergeCompilationDatabases(project: Project, name: String, paths: List[name]. Databases - * will be placed in a build dir in /compile_commands.json - */ -fun createCompilationDatabasesFromCompileToBitcodeTasks(project: Project, name: String) { - val compileTasks = project.tasks.withType(CompileToBitcode::class.java).toList() - val compdbTasks = compileTasks.groupBy({ task -> task.target }) { task -> - project.tasks.create("${task.name}_CompilationDatabase", - GenerateCompilationDatabase::class.java, - task.target, - task.inputFiles, - task.executable, - task.compilerFlags, - task.objDir) - } - for ((target, tasks) in compdbTasks) { - project.tasks.create("${target}${name}", MergeCompilationDatabases::class.java) { - dependsOn(tasks) - inputFiles.addAll(tasks.map { it.outputFile }) - outputFile = File(File(project.buildDir, target), "compile_commands.json") - } - } -} diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcode.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcode.kt index e01fc5ece37..b79636db2d7 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcode.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcode.kt @@ -212,9 +212,12 @@ abstract class CompileToBitcode @Inject constructor( } } + @Input + var outputName = "${folderName}.bc" + @get:OutputFile val outFile: File - get() = File(targetDir, "${folderName}.bc") + get() = File(targetDir, outputName) @get:Inject abstract val workerExecutor: WorkerExecutor diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcodePlugin.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcodePlugin.kt index 79371b4d1e9..9eeafe21f9c 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcodePlugin.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/bitcode/CompileToBitcodePlugin.kt @@ -7,31 +7,30 @@ package org.jetbrains.kotlin.bitcode import org.gradle.api.Plugin import org.gradle.api.Project +import org.gradle.api.Task import org.gradle.api.plugins.BasePlugin -import org.jetbrains.kotlin.createCompilationDatabasesFromCompileToBitcodeTasks +import org.jetbrains.kotlin.GenerateCompilationDatabase +import org.jetbrains.kotlin.MergeCompilationDatabases import org.jetbrains.kotlin.konan.target.PlatformManager import org.jetbrains.kotlin.konan.target.SanitizerKind import org.jetbrains.kotlin.konan.target.supportedSanitizers +import org.jetbrains.kotlin.testing.native.CompileNativeTest +import org.jetbrains.kotlin.testing.native.GoogleTestExtension +import org.jetbrains.kotlin.testing.native.RunNativeTest +import org.jetbrains.kotlin.testing.native.RuntimeTestingPlugin import java.io.File import javax.inject.Inject /** * A plugin creating extensions to compile */ -open class CompileToBitcodePlugin: Plugin { - override fun apply(target: Project) = with(target) { - extensions.create(EXTENSION_NAME, CompileToBitcodeExtension::class.java, target) - - afterEvaluate { - // TODO: Support providers (https://docs.gradle.org/current/userguide/lazy_configuration.html) - // in database tasks and create them along with corresponding compile tasks (not in afterEvaluate). - createCompilationDatabasesFromCompileToBitcodeTasks(project, COMPILATION_DATABASE_TASK_NAME) - } +open class CompileToBitcodePlugin : Plugin { + override fun apply(target: Project) { + target.extensions.create(EXTENSION_NAME, CompileToBitcodeExtension::class.java, target) } companion object { const val EXTENSION_NAME = "bitcode" - const val COMPILATION_DATABASE_TASK_NAME = "CompilationDatabase" } } @@ -41,22 +40,48 @@ open class CompileToBitcodeExtension @Inject constructor(val project: Project) { provider { (rootProject.project(":kotlin-native").property("targetList") as? List<*>)?.filterIsInstance() ?: emptyList() } // TODO: Can we make it better? } - fun create( - name: String, - srcRoot: File = project.file("src/$name"), - outputGroup: String = "main", - configurationBlock: CompileToBitcode.() -> Unit = {} - ) { + private val allMainModulesTasks by lazy { + val name = project.name.capitalized + targetList.get().associateBy(keySelector = { it }, valueTransform = { + project.tasks.register("${it}$name") + }) + } + + private val allTestsTasks by lazy { + val name = project.name.capitalized + targetList.get().associateBy(keySelector = { it }, valueTransform = { + project.tasks.register("${it}${name}Tests") + }) + } + + private val compdbTasks by lazy { + targetList.get().associateBy(keySelector = { it }, valueTransform = { + val task = project.tasks.register("${it}${COMPILATION_DATABASE_TASK_NAME}", MergeCompilationDatabases::class.java) + task.configure { + outputFile = File(File(project.buildDir, it), "compile_commands.json") + } + task + }) + } + + private fun addToCompdb(compileTask: CompileToBitcode) { + val task = project.tasks.create("${compileTask.name}_CompilationDatabase", GenerateCompilationDatabase::class.java, compileTask.target, compileTask.inputFiles, compileTask.executable, compileTask.compilerFlags, compileTask.objDir) + val compdbTask = compdbTasks[compileTask.target]!! + compdbTask.configure { + dependsOn(task) + inputFiles.add(task.outputFile) + } + } + + fun module(name: String, srcRoot: File = project.file("src/$name"), outputGroup: String = "main", configurationBlock: CompileToBitcode.() -> Unit = {}) { targetList.get().forEach { targetName -> val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager val target = platformManager.targetByName(targetName) val sanitizers: List = target.supportedSanitizers() + listOf(null) + val allMainModulesTask = allMainModulesTasks[targetName]!! sanitizers.forEach { sanitizer -> - project.tasks.register( - "${targetName}${name.snakeCaseToCamelCase().replaceFirstChar { it.uppercase() }}${suffixForSanitizer(sanitizer)}", - CompileToBitcode::class.java, - name, targetName, outputGroup - ).configure { + val taskName = fullTaskName(name, targetName, sanitizer) + val task = project.tasks.create(taskName, CompileToBitcode::class.java, name, targetName, outputGroup).apply { srcDirs = project.files(srcRoot.resolve("cpp")) headersDirs = srcDirs + project.files(srcRoot.resolve("headers")) @@ -71,17 +96,120 @@ open class CompileToBitcodeExtension @Inject constructor(val project: Project) { dependsOn(":kotlin-native:dependencies:update") configurationBlock() } + addToCompdb(task) + if (outputGroup == "main" && sanitizer == null) { + allMainModulesTask.configure { + dependsOn(taskName) + } + } + } + } + } + + private fun createTestTask( + project: Project, + testName: String, + testedTaskNames: List, + sanitizer: SanitizerKind?, + ): Task { + val platformManager = project.project(":kotlin-native").findProperty("platformManager") as PlatformManager + val googleTestExtension = project.extensions.getByName(RuntimeTestingPlugin.GOOGLE_TEST_EXTENSION_NAME) as GoogleTestExtension + val testedTasks = testedTaskNames.map { + project.tasks.getByName(it) as CompileToBitcode + } + val target = testedTasks.map { + it.target + }.distinct().single() + val konanTarget = platformManager.targetByName(target) + val compileToBitcodeTasks = testedTasks.mapNotNull { + val name = "${it.name}TestBitcode" + val task = project.tasks.findByName(name) as? CompileToBitcode + ?: project.tasks.create(name, CompileToBitcode::class.java, "${it.folderName}Tests", target, "test").apply { + srcDirs = it.srcDirs + headersDirs = it.headersDirs + googleTestExtension.headersDirs + + this.sanitizer = sanitizer + excludeFiles = emptyList() + includeFiles = listOf("**/*Test.cpp", "**/*TestSupport.cpp", "**/*Test.mm", "**/*TestSupport.mm") + dependsOn(":kotlin-native:dependencies:update") + dependsOn("downloadGoogleTest") + compilerArgs.addAll(it.compilerArgs) + + addToCompdb(this) + } + if (task.inputFiles.count() == 0) null + else task + } + // TODO: Consider using sanitized versions. + val testFrameworkTasks = listOf(project.tasks.getByName(fullTaskName("googletest", target, null)) as CompileToBitcode, project.tasks.getByName(fullTaskName("googlemock", target, null)) as CompileToBitcode) + + val testSupportTask = project.tasks.getByName(fullTaskName("test_support", target, sanitizer)) as CompileToBitcode + + val mimallocEnabled = testedTaskNames.any { it.contains("mimalloc", ignoreCase = true) } + val compileTask = project.tasks.create( + "${testName}Compile", + CompileNativeTest::class.java, + testName, + konanTarget, + testSupportTask.outFile, + platformManager, + mimallocEnabled, + ).apply { + val tasksToLink = (compileToBitcodeTasks + testedTasks + testFrameworkTasks) + this.sanitizer = sanitizer + this.inputFiles.setFrom(tasksToLink.map { it.outFile }) + dependsOn(testSupportTask) + dependsOn(tasksToLink) + } + + val runTask = project.tasks.create( + testName, + RunNativeTest::class.java, + testName, + compileTask.outputFile, + ).apply { + this.sanitizer = sanitizer + dependsOn(compileTask) + } + + return runTask + } + + fun testsGroup( + testTaskName: String, + testedTaskNames: List, + ) { + val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager + targetList.get().forEach { targetName -> + val target = platformManager.targetByName(targetName) + val sanitizers: List = target.supportedSanitizers() + listOf(null) + val allTestsTask = allTestsTasks[targetName]!! + sanitizers.forEach { sanitizer -> + val name = fullTaskName(testTaskName, targetName, sanitizer) + val testedNames = testedTaskNames.map { + fullTaskName(it, targetName, sanitizer) + } + val task = createTestTask(project, name, testedNames, sanitizer) + allTestsTask.configure { + dependsOn(task) + } } } } companion object { - private fun String.snakeCaseToCamelCase() = - split('_').joinToString(separator = "") { word -> word.replaceFirstChar { it.uppercase() } } + private const val COMPILATION_DATABASE_TASK_NAME = "CompilationDatabase" - fun suffixForSanitizer(sanitizer: SanitizerKind?) = - when (sanitizer) { + private val String.capitalized: String + get() = replaceFirstChar { it.uppercase() } + + private fun String.snakeCaseToUpperCamelCase() = split('_').joinToString(separator = "") { it.capitalized } + + private fun fullTaskName(name: String, targetName: String, sanitizer: SanitizerKind?) = "${targetName}${name.snakeCaseToUpperCamelCase()}${sanitizer.suffix}" + + private val SanitizerKind?.suffix + get() = when (this) { null -> "" SanitizerKind.ADDRESS -> "_ASAN" SanitizerKind.THREAD -> "_TSAN" diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/NativeTest.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/NativeTest.kt index 61d6b2f3022..6421882d211 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/NativeTest.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/NativeTest.kt @@ -12,14 +12,11 @@ import org.gradle.api.* import org.gradle.api.file.ConfigurableFileCollection import org.gradle.api.tasks.* import org.gradle.api.model.ObjectFactory -import org.gradle.kotlin.dsl.getByType import org.gradle.process.ExecOperations import org.gradle.workers.WorkAction import org.gradle.workers.WorkParameters import org.gradle.workers.WorkerExecutor import org.jetbrains.kotlin.ExecClang -import org.jetbrains.kotlin.bitcode.CompileToBitcode -import org.jetbrains.kotlin.bitcode.CompileToBitcodeExtension import org.jetbrains.kotlin.konan.target.* import java.io.OutputStream @@ -81,15 +78,17 @@ abstract class CompileNativeTestJob : WorkAction { val execClang = ExecClang.create(objects, platformManager, llvmDir) val target = platformManager.targetByName(targetName) + val clangFlags = buildClangFlags(platformManager.platform(target).configurables) + if (target.family.isAppleFamily) { execClang.execToolchainClang(target) { executable = "clang++" - this.args = compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath) + this.args = clangFlags + compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath) } } else { execClang.execBareClang { executable = "clang++" - this.args = compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath) + this.args = clangFlags + compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath) } } } @@ -201,7 +200,7 @@ abstract class CompileNativeTest @Inject constructor( it.konanHome = project.project(":kotlin-native").projectDir it.llvmDir = project.file(project.findProperty("llvmDir")!!) - it.isInfoEnabled = logger.isInfoEnabled() + it.isInfoEnabled = logger.isInfoEnabled } workQueue.submit(CompileNativeTestJob::class.java, parameters) @@ -274,104 +273,4 @@ private fun buildClangFlags(configurables: Configurables): List = mutabl configurables.targetTriple } addAll(listOf("-triple", targetTriple.toString())) -}.toList() - -private fun createTestTask( - project: Project, - testName: String, - testedTaskNames: List, - sanitizer: SanitizerKind?, - configureCompileToBitcode: CompileToBitcode.() -> Unit = {} -): Task { - val platformManager = project.project(":kotlin-native").findProperty("platformManager") as PlatformManager - val googleTestExtension = project.extensions.getByName(RuntimeTestingPlugin.GOOGLE_TEST_EXTENSION_NAME) as GoogleTestExtension - val testedTasks = testedTaskNames.map { - project.tasks.getByName(it) as CompileToBitcode - } - val target = testedTasks.map { - it.target - }.distinct().single() - val konanTarget = platformManager.targetByName(target) - val compileToBitcodeTasks = testedTasks.mapNotNull { - val name = "${it.name}TestBitcode" - val task = project.tasks.findByName(name) as? CompileToBitcode ?: - project.tasks.create(name, - CompileToBitcode::class.java, - "${it.folderName}Tests", - target, "test" - ).apply { - srcDirs = it.srcDirs - headersDirs = it.headersDirs + googleTestExtension.headersDirs - - this.sanitizer = sanitizer - excludeFiles = emptyList() - includeFiles = listOf("**/*Test.cpp", "**/*TestSupport.cpp", "**/*Test.mm", "**/*TestSupport.mm") - dependsOn(it) - dependsOn("downloadGoogleTest") - compilerArgs.addAll(it.compilerArgs) - this.configureCompileToBitcode() - } - if (task.inputFiles.count() == 0) - null - else - task - } - // TODO: Consider using sanitized versions. - val testFrameworkTasks = listOf( - project.tasks.getByName("${target}Googletest") as CompileToBitcode, - project.tasks.getByName("${target}Googlemock") as CompileToBitcode - ) - - val testSupportTask = project.tasks.getByName("${target}TestSupport${CompileToBitcodeExtension.suffixForSanitizer(sanitizer)}") as CompileToBitcode - - val mimallocEnabled = testedTaskNames.any { it.contains("mimalloc", ignoreCase = true) } - val compileTask = project.tasks.create( - "${testName}Compile", - CompileNativeTest::class.java, - testName, - konanTarget, - testSupportTask.outFile, - platformManager, - mimallocEnabled, - ).apply { - val tasksToLink = (compileToBitcodeTasks + testedTasks + testFrameworkTasks) - this.sanitizer = sanitizer - this.inputFiles.setFrom(tasksToLink.map { it.outFile }) - this.clangArgs.addAll(buildClangFlags(platformManager.platform(konanTarget).configurables)) - dependsOn(testSupportTask) - dependsOn(tasksToLink) - } - - val runTask = project.tasks.create( - testName, - RunNativeTest::class.java, - testName, - compileTask.outputFile, - ).apply { - this.sanitizer = sanitizer - dependsOn(compileTask) - } - - return runTask -} - -// TODO: These tests should be created by `CompileToBitcodeExtension` -fun createTestTasks( - project: Project, - targetName: String, - testTaskName: String, - testedTaskNames: List, - configureCompileToBitcode: CompileToBitcode.() -> Unit = {} -): List { - val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager - val target = platformManager.targetByName(targetName) - val sanitizers: List = target.supportedSanitizers() + listOf(null) - return sanitizers.map { sanitizer -> - val suffix = CompileToBitcodeExtension.suffixForSanitizer(sanitizer) - val name = testTaskName + suffix - val testedNames = testedTaskNames.map { - it + suffix - } - createTestTask(project, name, testedNames, sanitizer, configureCompileToBitcode) - } -} +}.toList() \ No newline at end of file diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/RuntimeTestingPlugin.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/RuntimeTestingPlugin.kt index 0b818b8d459..1a4f009213a 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/RuntimeTestingPlugin.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/testing/native/RuntimeTestingPlugin.kt @@ -54,7 +54,7 @@ open class RuntimeTestingPlugin : Plugin { val bitcodeExtension = project.extensions.getByName(CompileToBitcodePlugin.EXTENSION_NAME) as CompileToBitcodeExtension - bitcodeExtension.create("googletest", outputGroup = "test") { + bitcodeExtension.module("googletest", outputGroup = "test") { srcDirs = project.files( googleTestRoot.resolve("googletest/src") ) @@ -69,7 +69,7 @@ open class RuntimeTestingPlugin : Plugin { dependsOn(dependencies) } - bitcodeExtension.create("googlemock", outputGroup = "test") { + bitcodeExtension.module("googlemock", outputGroup = "test") { srcDirs = project.files( googleTestRoot.resolve("googlemock/src") ) diff --git a/kotlin-native/common/build.gradle.kts b/kotlin-native/common/build.gradle.kts index 7c98c54ca68..a8ba5c6219e 100644 --- a/kotlin-native/common/build.gradle.kts +++ b/kotlin-native/common/build.gradle.kts @@ -8,19 +8,14 @@ plugins { } bitcode { - create("files"){ - dependsOn(":kotlin-native:dependencies:update") - } - create("env"){ - dependsOn(":kotlin-native:dependencies:update") - } + module("files") + module("env") } val hostName: String by project val build by tasks.registering { - dependsOn("${hostName}Files") - dependsOn("${hostName}Env") + dependsOn("${hostName}Common") } val clean by tasks.registering { diff --git a/kotlin-native/runtime/build.gradle.kts b/kotlin-native/runtime/build.gradle.kts index 8007ce68f8f..6996e45290e 100644 --- a/kotlin-native/runtime/build.gradle.kts +++ b/kotlin-native/runtime/build.gradle.kts @@ -3,7 +3,6 @@ * that can be found in the LICENSE file. */ import org.jetbrains.kotlin.* -import org.jetbrains.kotlin.testing.native.* import org.jetbrains.kotlin.bitcode.CompileToBitcode import org.jetbrains.kotlin.gradle.plugin.konan.tasks.KonanCacheTask import org.jetbrains.kotlin.konan.properties.loadProperties @@ -41,33 +40,13 @@ val hostName: String by project val targetList: List by project bitcode { - create("runtime", file("src/main")) { - dependsOn( - ":kotlin-native:dependencies:update", - "${target}StdAlloc", - "${target}OptAlloc", - "${target}Mimalloc", - "${target}Libbacktrace", - "${target}Launcher", - "${target}Debug", - "${target}SourceInfoCoreSymbolication", - "${target}SourceInfoLibbacktrace", - "${target}Strict", - "${target}Relaxed", - "${target}ProfileRuntime", - "${target}Objc", - "${target}ExceptionsSupport", - "${target}LegacyMemoryManager", - "${target}ExperimentalMemoryManager", - "${target}CommonGc", - "${target}SameThreadMsGc", - "${target}ConcurrentMsGc", - "${target}NoopGc" - ) + module("main") { includeRuntime() + + outputName = "runtime.bc" } - create("mimalloc") { + module("mimalloc") { val srcRoot = file("src/mimalloc") language = CompileToBitcode.Language.C includeFiles = listOf("**/*.c") @@ -82,7 +61,7 @@ bitcode { onlyIf { targetSupportsMimallocAllocator(target) } } - create("libbacktrace") { + module("libbacktrace") { val srcRoot = file("src/libbacktrace") val targetInfo = HostManager().targetByName(target) language = CompileToBitcode.Language.C @@ -122,231 +101,102 @@ bitcode { } - create("launcher") { + module("launcher") { includeRuntime() } - create("debug") { + module("debug") { includeRuntime() } - create("std_alloc") { + module("std_alloc") { includeRuntime() } - create("opt_alloc") { + module("opt_alloc") { includeRuntime() } - create("exceptionsSupport", file("src/exceptions_support")) { + module("exceptionsSupport", file("src/exceptions_support")) { includeRuntime() } - create("source_info_core_symbolication", file("src/source_info/core_symbolication")) { + module("source_info_core_symbolication", file("src/source_info/core_symbolication")) { includeRuntime() onlyIf { targetSupportsCoreSymbolication(target) } } - create("source_info_libbacktrace", file("src/source_info/libbacktrace")) { + module("source_info_libbacktrace", file("src/source_info/libbacktrace")) { includeRuntime() headersDirs += files("src/libbacktrace/c/include") onlyIf { targetSupportsLibBacktrace(target) } } - create("strict") { + module("strict") { includeRuntime() } - create("relaxed") { + module("relaxed") { includeRuntime() } - create("profileRuntime", file("src/profile_runtime")) + module("profileRuntime", file("src/profile_runtime")) - create("objc") { + module("objc") { includeRuntime() } - create("test_support", outputGroup = "test") { + module("test_support", outputGroup = "test") { includeRuntime() dependsOn("downloadGoogleTest") headersDirs += googletest.headersDirs } - create("legacy_memory_manager", file("src/legacymm")) { + module("legacy_memory_manager", file("src/legacymm")) { includeRuntime() } - create("experimental_memory_manager", file("src/mm")) { + module("experimental_memory_manager", file("src/mm")) { headersDirs += files("src/gc/common/cpp") includeRuntime() } - create("common_gc", file("src/gc/common")) { + module("common_gc", file("src/gc/common")) { headersDirs += files("src/mm/cpp") includeRuntime() } - create("noop_gc", file("src/gc/noop")) { + module("noop_gc", file("src/gc/noop")) { headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp") includeRuntime() } - create("same_thread_ms_gc", file("src/gc/stms")) { + module("same_thread_ms_gc", file("src/gc/stms")) { headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp") includeRuntime() } - create("concurrent_ms_gc", file("src/gc/cms")) { + module("concurrent_ms_gc", file("src/gc/cms")) { headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp") includeRuntime() onlyIf { targetSupportsThreads(target) } } -} -targetList.forEach { targetName -> - val allTests = mutableListOf() + testsGroup("std_alloc_runtime_tests", listOf("main", "legacy_memory_manager", "strict", "std_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}StdAllocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}LegacyMemoryManager", - "${targetName}Strict", - "${targetName}StdAlloc", - "${targetName}Objc" - ) - ) { - includeRuntime() - }) + testsGroup("mimalloc_runtime_tests", listOf("main", "legacy_memory_manager", "strict", "mimalloc", "opt_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}MimallocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}LegacyMemoryManager", - "${targetName}Strict", - "${targetName}Mimalloc", - "${targetName}OptAlloc", - "${targetName}Objc" - ) - ) { - includeRuntime() - }) + testsGroup("experimentalMM_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "same_thread_ms_gc", "mimalloc", "opt_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMMimallocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}SameThreadMsGc", - "${targetName}Mimalloc", - "${targetName}OptAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) + testsGroup("experimentalMM_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "same_thread_ms_gc", "std_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMStdAllocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}SameThreadMsGc", - "${targetName}StdAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) + testsGroup("experimentalMM_cms_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "concurrent_ms_gc", "mimalloc", "opt_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMCmsMimallocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}ConcurrentMsGc", - "${targetName}Mimalloc", - "${targetName}OptAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) + testsGroup("experimentalMM_cms_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "concurrent_ms_gc", "std_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMCmsStdAllocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}ConcurrentMsGc", - "${targetName}StdAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) + testsGroup("experimentalMM_noop_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "noop_gc", "mimalloc", "opt_alloc", "objc")) - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMNoOpMimallocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}NoopGc", - "${targetName}Mimalloc", - "${targetName}OptAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) - - allTests.addAll(createTestTasks( - project, - targetName, - "${targetName}ExperimentalMMNoOpStdAllocRuntimeTests", - listOf( - "${targetName}Runtime", - "${targetName}ExperimentalMemoryManager", - "${targetName}CommonGc", - "${targetName}NoopGc", - "${targetName}StdAlloc", - "${targetName}Objc" - ) - ) { - headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp") - includeRuntime() - }) - - // TODO: This "all tests" tasks should be provided by `CompileToBitcodeExtension` - tasks.register("${targetName}RuntimeTests") { - dependsOn(allTests) - } + testsGroup("experimentalMM_noop_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "noop_gc", "std_alloc", "objc")) } val hostRuntime by tasks.registering { @@ -357,32 +207,12 @@ val hostRuntimeTests by tasks.registering { dependsOn("${hostName}RuntimeTests") } -val hostStdAllocRuntimeTests by tasks.registering { - dependsOn("${hostName}StdAllocRuntimeTests") -} - -val hostMimallocRuntimeTests by tasks.registering { - dependsOn("${hostName}MimallocRuntimeTests") -} - -val hostExperimentalMMStdAllocRuntimeTests by tasks.registering { - dependsOn("${hostName}ExperimentalMMStdAllocRuntimeTests") -} - -val hostExperimentalMMMimallocRuntimeTests by tasks.registering { - dependsOn("${hostName}ExperimentalMMMimallocRuntimeTests") -} - val assemble by tasks.getting { - dependsOn(tasks.withType(CompileToBitcode::class).matching { - it.outputGroup == "main" - }) + dependsOn(targetList.forEach { "${it}Runtime" }) } val hostAssemble by tasks.registering { - dependsOn(tasks.withType(CompileToBitcode::class).matching { - it.outputGroup == "main" && it.target == hostName - }) + dependsOn("${hostName}Runtime") } val clean by tasks.getting {