// threadpool of GPU event mgr, as that can trigger more callbacks to be
  // scheduled on that same threadpool, causing a deadlock in cases where the
  // caller of event_mgr->ThenExecute() blocks on the completion of the callback
  // (as in the case of ConstOp kernel creation on GPU, which involves copying a
  // CPU tensor to GPU).
  // Setting a larger thread pool does not help with the Swift caller, as we use

	go func() {
		defer close(errCh)
		// Merge all entries from all disks.
		// We leave quorum at 1, since entries are already resolved to have the desired quorum.
		// mergeEntryChannels will close 'merged' channel upon completion or cancellation.
		errCh <- mergeEntryChannels(ctx, entries, merged, 1)
	}()

	return nil
}

// HealObjectFn closure function heals the object.

and there are no missing null checks.

## Decision

Use "NullAway" in JSpecify mode to check for null-related errors in Java code.

Consider improper uses of `null` detected by NullAway a compilation error (not a warning, and not a separate CI job to test).

Do not suppress NullAway errors without a justification.

#!/bin/bash

set -ex

function _init() {
	## All binaries are static make sure to disable CGO.
	export CGO_ENABLED=0
	export CRED_DIR="/media/${USER}/minio"

	## List of architectures and OS to test coss compilation.
	SUPPORTED_OSARCH="linux/ppc64le linux/amd64 linux/arm64"

	remote=$(git remote get-url upstream)
	if test "$remote" != "******@****.***:minio/minio.git"; then

    id("gradlebuild.jvm-compile")
}

tasks.withType<JavaCompile>().configureEach {
    options.release = provider {
        throw GradleException("This task '${name}' is not associated with a compilation. Associate it with a compilation on the '${JvmCompileExtension.NAME}' extension.")
    }
}

val gradleModule = the<GradleModuleExtension>()
the<JvmCompileExtension>().apply {
    compilations {
        configureEach {

            "errorprone",
            project.objects.property<Boolean>()
        ).apply {
            // Enable it only for the main source set by default, as incremental Groovy
            // joint-compilation doesn't work with the Error Prone annotation processor
            enabled.convention(isMainSourceSet)
        }

        if (isMainSourceSet) {

 */
val keepPatterns = mapOf(
    "it.unimi.dsi:fastutil" to setOf(
        // For persistence cache
        "it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap",
        // For Java compilation incremental analysis
        "it.unimi.dsi.fastutil.ints.IntOpenHashSet",
        "it.unimi.dsi.fastutil.ints.IntSets",
        // For the embedded Kotlin compiler
        "it.unimi.dsi.fastutil.ints.Int2ObjectMap",

    "groups" : [ {
      "testProject" : "largeJavaMultiProject",
      "comment" : "We only test the multi-project here since for the monolithic project we would have no cache hits. This would mean we actually would test incremental compilation.",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {

        <dslContextParameter.branch>master</dslContextParameter.branch>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- https://kotlinlang.org/docs/maven.html#enable-incremental-compilation -->
        <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
    </properties>
    <groupId>Gradle_Check</groupId>
    <artifactId>Gradle_Check_dsl</artifactId>
    <version>1.0-SNAPSHOT</version>

# Set lld as the linker.
common:cuda_clang --host_linkopt="-fuse-ld=lld"
common:cuda_clang --host_linkopt="-lm"
common:cuda_clang --linkopt="-fuse-ld=lld"
common:cuda_clang --linkopt="-lm"

# Set up compilation CUDA version and paths and use the CUDA Clang toolchain.
common:cuda_clang_official --config=cuda_clang
common:cuda_clang_official --config=cuda_version

# Build with nvcc for CUDA and clang for host