// sets to be reused by f.newSparseMapPos.
func (f *Func) retSparseMapPos(ss *sparseMapPos) {
	f.Cache.freeSparseMapPos(ss)
}

// newPoset returns a new poset from the internal cache
func (f *Func) newPoset() *poset {
	if len(f.Cache.scrPoset) > 0 {
		po := f.Cache.scrPoset[len(f.Cache.scrPoset)-1]
		f.Cache.scrPoset = f.Cache.scrPoset[:len(f.Cache.scrPoset)-1]
		return po
	}

  /**
   * Closes the cache and deletes all of its stored values. This will delete all files in the cache
   * directory including files that weren't created by the cache.
   */
  @Throws(IOException::class)
  fun delete() {
    cache.delete()
  }

  /**
   * Deletes all values stored in the cache. In-flight writes to the cache will complete normally,
   * but the corresponding responses will not be stored.
   */

var emptymspan mspan

func allocmcache() *mcache {
	var c *mcache
	systemstack(func() {
		lock(&mheap_.lock)
		c = (*mcache)(mheap_.cachealloc.alloc())
		c.flushGen.Store(mheap_.sweepgen)
		unlock(&mheap_.lock)
	})
	for i := range c.alloc {
		c.alloc[i] = &emptymspan
	}
	c.nextSample = nextSample()
	return c
}

// freemcache releases resources associated with this
// mcache and puts the object onto a free list.
//

// Copyright 2023 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.

package dcache

import (
	"./aconfig"
	"./bresource"
	"./cmem"
)

type Module struct {
	cfg  *aconfig.Config
	err  error
	last any
}

//go:noinline
func TD() {
}

func (m *Module) Configure(x string) error {
	if m.err != nil {
		return m.err
	}

import org.gradle.cache.FileLockManager;
import org.gradle.cache.IndexedCacheParameters;
import org.gradle.cache.InsufficientLockModeException;
import org.gradle.cache.LockOptions;
import org.gradle.cache.LockTimeoutException;
import org.gradle.cache.MultiProcessSafeIndexedCache;
import org.gradle.cache.internal.btree.BTreePersistentIndexedCache;
import org.gradle.cache.internal.cacheops.CacheAccessOperationsStack;

env GOCACHE=$WORK/cache

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache

[!fuzz-instrumented] skip

[short] skip
env GOCACHE=$WORK/cache

# Fuzz cache should not exist after a regular test run.
go test .
exists $GOCACHE
! exists $GOCACHE/fuzz

# Fuzzing should write interesting values to the cache.
go test -fuzz=FuzzY -fuzztime=100x .
go run ./contains_files $GOCACHE/fuzz/example.com/y/FuzzY

# 'go clean -cache' should not delete the fuzz cache.
go clean -cache
exists $GOCACHE/fuzz

# With all three set, we should prefer GOCACHE.
go env GOCACHE
stdout $WORK'/gocache$'

# Without GOCACHE, we should prefer XDG_CACHE_HOME over HOME.
env GOCACHE=
go env GOCACHE
stdout $WORK'/xdg/go-build$$'

# With only HOME set, we should use $HOME/.cache.
env XDG_CACHE_HOME=
go env GOCACHE
stdout $WORK'/home/.cache/go-build$'

# With no guidance from the environment, we must disable the cache, but that

env GOCACHE=test
! go build -o triv triv.go
stderr 'build cache is required, but could not be located: GOCACHE is not an absolute path'

# An explicit GOCACHE=off also disables builds.
env GOCACHE=off
! go build -o triv triv.go
stderr 'build cache is disabled by GOCACHE=off'

# If GOCACHE is set to an unwritable directory, we should diagnose it as such.
[GOOS:windows] stop # Does not support unwritable directories.

[short] skip

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building trivial non-main package should run preprofile the first time.
go build -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'

# ... but not again ...
go build -x -pgo=default.pgo lib.go
! stderr 'preprofile.*default\.pgo'

# ... unless we use -a.
go build -a -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'