The Mouse did not answer, so Alice went on eagerly:  `There is
such a nice little dog near our house I should like to show you!
A little bright-eyed terrier, you know, with oh, such long curly
brown hair!  And it'll fetch things when you throw them, and
it'll sit up and beg for its dinner, and all sorts of things--I
can't remember half of them--and it belongs to a farmer, you

		return 8, nil
	case []float32:
		return 4 * len(data), nil
	case []float64:
		return 8 * len(data), nil
	}
	return 0, nil
}

// ensure grows buf to length len(buf) + n and returns the grown buffer
// and a slice starting at the original length of buf (that is, buf2[len(buf):]).
func ensure(buf []byte, n int) (buf2, pos []byte) {
	l := len(buf)
	buf = slices.Grow(buf, n)[:l+n]
	return buf, buf[l:]

The Mouse did not answer, so Alice went on eagerly:  `There is
such a nice little dog near our house I should like to show you!
A little bright-eyed terrier, you know, with oh, such long curly
brown hair!  And it'll fetch things when you throw them, and
it'll sit up and beg for its dinner, and all sorts of things--I
can't remember half of them--and it belongs to a farmer, you

	sc.value.Store(ssc.pack())
}

// scavChunkData tracks information about a palloc chunk for
// scavenging. It packs well into 64 bits.
//
// The zero value always represents a valid newly-grown chunk.
type scavChunkData struct {
	// inUse indicates how many pages in this chunk are currently
	// allocated.
	//
	// Only the first 10 bits are used.
	inUse uint16

pkg syscall (openbsd-386), type FdSet struct, Bits [32]uint32
pkg syscall (openbsd-386), type Kevent_t struct, Data int64
pkg syscall (openbsd-386), type Mclpool struct, Grown int32
pkg syscall (openbsd-386), type RtMetrics struct, Expire int64
pkg syscall (openbsd-386), type RtMetrics struct, Pad uint32
pkg syscall (openbsd-386), type Stat_t struct, Ino uint64

// osPreemptExtEnter is called before entering external code that may
// call ExitProcess.
//
// This must be nosplit because it may be called from a syscall with
// untyped stack slots, so the stack must not be grown or scanned.
//
//go:nosplit
func osPreemptExtEnter(mp *m) {
	for !atomic.Cas(&mp.preemptExtLock, 0, 1) {
		// An asynchronous preemption is in progress. It's not

	if b := (offAddr{base}); b.lessThan(p.searchAddr) {
		p.searchAddr = b
	}

	// Add entries into chunks, which is sparse, if needed. Then,
	// initialize the bitmap.
	//
	// Newly-grown memory is always considered scavenged.
	// Set all the bits in the scavenged bitmaps high.
	for c := chunkIndex(base); c < chunkIndex(limit); c++ {
		if p.chunks[c.l1()] == nil {
			// Create the necessary l2 entry.

func timeSleepUntil() int64 {
	next := int64(maxWhen)

	// Prevent allp slice changes. This is like retake.
	lock(&allpLock)
	for _, pp := range allp {
		if pp == nil {
			// This can happen if procresize has grown
			// allp but not yet created new Ps.
			continue
		}

		if w := pp.timers.wakeTime(); w != 0 {
			next = min(next, w)
		}
	}
	unlock(&allpLock)

	return next
}

	heapArenaAlloc linearAlloc

	// arenaHints is a list of addresses at which to attempt to
	// add more heap arenas. This is initially populated with a
	// set of general hint addresses, and grown with the bounds of
	// actual heap arena ranges.
	arenaHints *arenaHint

	// arena is a pre-reserved space for allocating heap arenas
	// (the actual arenas). This is only used on 32-bit.
	arena linearAlloc

		// give the sweeper some runway if it doesn't have enough.
		c.sweepDistMinTrigger.Store(c.heapLive.Load() + sweepMinHeapDistance)
	}

	// Compute the next GC goal, which is when the allocated heap
	// has grown by GOGC/100 over where it started the last cycle,
	// plus additional runway for non-heap sources of GC work.
	gcPercentHeapGoal := ^uint64(0)
	if gcPercent := c.gcPercent.Load(); gcPercent >= 0 {