/**
     * On a CC miss, should we load the newly stored state in the same invocation?
     *
     * This provides a benefit of discarding a lot of state (e.g. project state) earlier in the build,
     * potentially reducing the memory consumption.
     * Another key benefit is that this eliminates discrepancies in behavior between cache hits and misses.
     *
     * We disable load-after-store when tooling model builders are involved.

        1 * writeStore.add(key, action)
        0 * readStore.add(key, action)
    }

    def "searches in both read and write stores"() {
        setup:
        def r1 = Stub(LocallyAvailableResource)
        def r2 = Stub(LocallyAvailableResource)
        def r3 = Stub(LocallyAvailableResource)
        1 * writeStore.search(key) >> {
            [r1] as Set
        }
        1 * readStore.search(key) >> {

}

func (v *Map) Set(key string, av Var) {
	// Before we store the value, check to see whether the key is new. Try a Load
	// before LoadOrStore: LoadOrStore causes the key interface to escape even on
	// the Load path.
	if _, ok := v.m.Load(key); !ok {
		if _, dup := v.m.LoadOrStore(key, av); !dup {
			v.addKey(key)
			return
		}
	}

	v.m.Store(key, av)
}

// a single second.
type unixStat struct {
	unixTime int64
	requests int64
}

type droppedRequestsStats struct {
	lock sync.RWMutex

	// history stores the history of dropped requests.
	history []unixStat

	// To reduce lock-contention, we store the information about
	// the current second here, which we can then access under
	// reader lock.
	currentUnix  int64
	currentCount atomic.Int64

	// it nils the slot, at which point ownership passes to the
	// producer.
	//
	// The head index is stored in the most-significant bits so
	// that we can atomically add to it and the overflow is
	// harmless.
	headTail atomic.Uint64

	// vals is a ring buffer of interface{} values stored in this
	// dequeue. The size of this must be a power of 2.
	//
	// vals[i].typ is nil if the slot is empty and non-nil

type PushQueue struct {
	cond *sync.Cond

	// pending stores all connections in the queue. If the same connection is enqueued again,
	// the PushRequest will be merged.
	pending map[*Connection]*model.PushRequest

	// queue maintains ordering of the queue
	queue []*Connection

	// processing stores all connections that have been Dequeue(), but not MarkDone().

//go:noescape
func Cas64(ptr *uint64, old, new uint64) bool

//go:noescape
func CasRel(ptr *uint32, old, new uint32) bool

//go:noescape
func Store(ptr *uint32, val uint32)

//go:noescape
func Store8(ptr *uint8, val uint8)

//go:noescape
func Store64(ptr *uint64, val uint64)

// NO go:noescape annotation; see atomic_pointer.go.
func StorepNoWB(ptr unsafe.Pointer, val unsafe.Pointer)

     * @return The file where the signature has been written to
     */
    File sign(Signatory signatory, File toSign);

    /**
     * Signs the data from the given InputStream and stores the signature in the given OutputStream.
     *
     * @param signatory The signatory
     * @param toSign The source of the data to be signed
     * @param destination Where the signature will be written to
     */

export WINDOWS_NODE_DIR="${WINDOWS_K8S_DIR}\node\bin"
# Directory where Kubernetes log files will be stored on Windows nodes.
export WINDOWS_LOGS_DIR="${WINDOWS_K8S_DIR}\logs"
# Directory where CNI binaries will be stored on Windows nodes.
export WINDOWS_CNI_DIR="${WINDOWS_K8S_DIR}\cni"
# Directory where CNI config files will be stored on Windows nodes.
export WINDOWS_CNI_CONFIG_DIR="${WINDOWS_K8S_DIR}\cni\config"

type ResultFunc func() (runtime.Object, error)

// result stores the return values or panic from a ResultFunc function
type result struct {
	// object stores the response returned by the ResultFunc function
	object runtime.Object
	// err stores the error returned by the ResultFunc function
	err error
	// reason stores the reason from a panic thrown by the ResultFunc function
	reason interface{}
}