boolean getAllowsParallelExecution();

    /**
     * Releases any project state locks or task execution locks currently held by the current thread and executes the {@link Factory}.
     * Upon completion of the {@link Factory}, if a lock was held at the time the method was called, then it will be reacquired.
     * If no locks were held at the time the method was called, then no attempt will be made to reacquire a lock on completion.

		println("<none>")
		return
	}

	for j, held := range gp.m.locksHeld[:gp.m.locksHeldLen] {
		println(j, ":", held.rank.String(), held.rank, unsafe.Pointer(gp.m.locksHeld[j].lockAddr))
	}
}

// acquireLockRankAndM acquires a rank which is not associated with a mutex
// lock. To maintain the invariant that an M with m.locks==0 does not hold any
// lock-like resources, it also acquires the M.
//

     * Fetches the value from this cache. A shared or exclusive lock is held while fetching the value, depending on implementation.
     */
    T get();

    /**
     * Sets the value for this cache. An exclusive lock is held while setting the value.
     */
    void set(T newValue);

    /**
     * Replaces the value for this cache.
     *
     * An exclusive lock is held while the update action is executing.

     */
    @Override
    void put(K key, V value);

    /**
     * Removes a key-value mapping from this cache. A shared lock is held while updating the value.
     *
     * The implementation may do this synchronously or asynchronously. A file lock is held until the value has been removed from the persistent store.
     */

public interface ResourceLockRegistry {
    /**
     * Get all of the resource locks held by the current thread.
     */
    Collection<? extends ResourceLock> getResourceLocksByCurrentThread();

    /**
     * Returns true if the registry has any locks that are being held by a thread.
     *
     * @return true if any locks in the registry are currently held.
     */
    boolean hasOpenLocks();

import org.gradle.internal.serialize.Serializer;

import java.io.Closeable;
import java.io.File;

/**
 * Represents a directory that can be used for caching.
 *
 * <p>By default, a shared lock is held on this cache by this process, to prevent it being removed or rebuilt by another process
 * while it is in use. You can change this use {@link CacheBuilder#withInitialLockMode(org.gradle.cache.FileLockManager.LockMode)}.
 *

    boolean lockIsHeld(final ResourceLock resourceLock) {
        MutableBoolean held = new MutableBoolean()
        coordinationService.withStateLock(new InternalTransformer<ResourceLockState.Disposition, ResourceLockState>() {
            @Override
            ResourceLockState.Disposition transform(ResourceLockState resourceLockState) {
                held.set(resourceLock.locked && resourceLock.isLockedByCurrentThread())

        super(displayName, coordinationService, owner);
        this.allProjectsLock = allProjectsLock;
    }

    @Override
    protected boolean canAcquire() {
        // Either the "all projects" lock is not held, or it is held by this thread
        return !allProjectsLock.isLocked() || allProjectsLock.isLockedByCurrentThread();
    }

    /**
     * Opens this cache access instance when the cache is opened. State lock is held while this method is called.
     */
    public abstract void open();

    /**
     * Closes this cache access instance when the cache is opened. State lock is held while this method is called.
     */
    @Override
    public abstract void close();

    for (int i = 0; i < length; i++) {
      Object key = new Object();
      // TODO(b/145386688): This access should be guarded by 'this.segment', which is not currently
      // held
      chain = segment.newEntry(key, cache.hash(key), chain);
      if (i == 0) {
        head = chain;
      }
    }
  }

  @SuppressWarnings("GuardedBy")
  @Benchmark
  int time(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {