def block2 = blockingServer.expectAndBlock("block2")

        // Build 1 should download module 1 and reuse cached module 2 state
        mod1.pom.expectGet()
        mod1.artifact.expectGet()

        // Build 2 should download module 2 and reuse cached module 1 state
        mod2.pom.expectGet()
        mod2.artifact.expectGet()

        // Start build 1 then wait until it has run task 'a'.

	}
}

// GetLease returns a lease based on requested ttl: if the cached previous
// lease can be reused, reuse it; otherwise request a new one from etcd.
func (l *leaseManager) GetLease(ctx context.Context, ttl int64) (clientv3.LeaseID, error) {
	now := time.Now()
	l.leaseMu.Lock()
	defer l.leaseMu.Unlock()
	// check if previous lease can be reused
	reuseDurationSeconds := l.getReuseDurationSecondsLocked(ttl)

                            log.debug("Cannot reuse, signing enforced on connection " + conn);
                        }
                        continue;
                    }

                    if ( !conn.getNegotiateResponse().canReuse(tc, forceSigning) ) {
                        if ( log.isTraceEnabled() ) {
                            log.trace("Cannot reuse, different config " + conn);
                        }

# Verify PPC64 does not reuse a trampoline which is too far away.
# This tests an edge case where the direct call relocation addend should
# be ignored when computing the distance from the direct call to the
# already placed trampoline
[short] skip
[!GOARCH:ppc64] [!GOARCH:ppc64le] skip
[GOOS:aix] skip

# Note, this program does not run. Presumably, 'DWORD $0' is simpler to
# assembly 2^26 or so times.
#

	p = pthread_self();
	addr = pthread_get_stackaddr_np(p); // high address (!)
	size = pthread_get_stacksize_np(p);

	// bounds points into the Go stack. TSAN can't see the synchronization
	// in Go around stack reuse.
	_cgo_tsan_acquire();
	bounds[0] = (uintptr)addr - size;
	bounds[1] = (uintptr)addr;
	_cgo_tsan_release();

}
"""
        expect:
        def block1 = blockingServer.expectAndBlock("block1")
        def block2 = blockingServer.expectAndBlock("block2")

        // Build 1 should download module 1 and check whether it can reuse module 2 files
        mod1.pom.expectGet()
        mod1.artifact.expectGet()
        if (previous.version <= GradleVersion.version("1.8")) {
            mod2.pom.expectGet()
            mod2.artifact.expectGet()

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections:

// asmcheck

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Make sure we reuse large constant loads, if we can.
// See issue 33580.

package codegen

const (
	A = 7777777777777777
	B = 8888888888888888
)

func f(x, y uint64) uint64 {
	p := x & A
	q := y & A
	r := x & B
	// amd64:-"MOVQ.*8888888888888888"

        // TODO:REUSE Refactor after removing reuse
        // This is horrendously bad.
        // We need to set the platform, _before_ the @Defaults rules of NativeBinaryRules assign the toolchain.
        // We can't just assign the toolchain here because the initializer would be closing over the toolchain which is not reusable, and this breaks model reuse.

  }

  // Maybe add a Transpose node for all operands (or reuse existing transposes).
  OpBuilder builder(op);
  builder.setInsertionPoint(op);

  for (OpOperand& operand : op->getOpOperands()) {
    // Try to push transpose further up.
    if (Operation* operand_op = operand.get().getDefiningOp())
      work_list->push_back(operand_op);

    // Try to reuse result transposes.
    TransposeOp transpose = ReuseExistingTranspose(