DeviceCompilationCache<ExecutableType>::Lookup(const Key& key) const {
  // The outer lock protects the existence of the cache entry. It does not
  // protect the contents of the cache entry.
  Entry* entry;
  {
    mutex_lock lock(compile_cache_mu_);
    // Find cache entry.
    auto it = cache_.find(key);
    if (it == cache_.cend()) {
      return std::nullopt;
    }

    entry = it->second.get();
  }

   * Cache.asMap().putIfAbsent} after loading has completed; if another value was associated with
   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *
   * <p>If the cache loader associated with this cache is known not to throw checked exceptions,
   * then prefer {@link #getUnchecked} over this method.
   *

        }
        return last;
    }

    /**
     * Caches calls to the transform chain selection algorithm. The cached results are stored in
     * a variant-independent manner, such that only the attributes of the input variants are cached.
     * This way, if multiple calls are made with different variants but those variants have the same
     * attributes, the cached results may be used.
     */
    private static class TransformCache {

        then:
        m.group == 'foo'
        m.name == 'bar'
    }

    def "caches module ids"() {
        when:
        def m1 = factory.module('foo', 'bar')
        def m2 = factory.module('foo', 'bar')

        then:
        m1.is(m2)
    }

    def "caches modules with versions"() {
        when:
        def m1 = factory.moduleWithVersion('foo', 'bar', '1.0')

As stated above, caches in Gradle User Home are version-specific.
Different versions of Gradle will perform maintenance on only the version-specific caches associated with each version.

On the other hand, some caches are shared between versions (e.g., the dependency artifact cache or the artifact transform cache).

Beginning with Gradle version 8.0, the cache cleanup settings can be configured to custom retention periods.

    - name: Cache Gradle Modules
      uses: actions/cache@v4
      with:
        path: |
          ~/.gradle/caches/modules-2/
          ~/.gradle/caches/build-cache-1/
          ~/.gradle/caches/signatures/
          ~/.gradle/caches/keyrings/
        key: ${{ runner.os }}-gradle-cache-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}

// alongside the cached BoringCrypto key and check that the real key
// still matches before using the cached key. The theory is that the real
// operations are significantly more expensive than the comparison.

type boringPub struct {
	key  *boring.PublicKeyRSA
	orig PublicKey
}

var pubCache bcache.Cache[PublicKey, boringPub]
var privCache bcache.Cache[PrivateKey, boringPriv]

func init() {

Shinsuke Sugaya <******@****.***> 1462510149 +0900

Shinsuke Sugaya <******@****.***> 1462510149 +0900

cache-admin-hit-rate.png...