"context"
	"fmt"
	"sync"
)

// RateLimiter abstracts the rate limiter used by RateLimitedSafeWaitGroup.
// The implementation must be thread-safe.
type RateLimiter interface {
	Wait(ctx context.Context) error
}

// RateLimiterFactoryFunc is used by the RateLimitedSafeWaitGroup to create a new
// instance of a RateLimiter that will be used to rate limit the return rate

	ucfg.rate = make(map[pgkey]float64)
	for _, p := range ucfg.Programs {
		ucfg.program[p.Name] = true
		for _, v := range p.Versions {
			ucfg.pgversion[pgkey{p.Name, v}] = true
		}
		for _, c := range p.Counters {
			for _, e := range Expand(c.Name) {
				ucfg.pgcounter[pgkey{p.Name, e}] = true
				ucfg.rate[pgkey{p.Name, e}] = c.Rate
			}
			prefix, _, found := strings.Cut(c.Name, ":")

func main() {
	fmt.Println("Hello, world!")
}
-- .Output --
Hello, world!
-- Limiter.Play --
package main

import (
	"fmt"
	"time"

	"golang.org/x/time/rate"
)

func main() {
	// Uses fmt, time and rate.
	l := rate.NewLimiter(rate.Every(time.Second), 1)
	fmt.Println(l)

)

func main() {
	fmt.Println("Hello, world!")
}
-- .Output --
Hello, world!
-- Limiter.Play --
package main

import (
	"fmt"
	tm "time"

	r "golang.org/x/time/rate"
)

func main() {
	// Uses fmt, time and rate.
	l := r.NewLimiter(r.Every(tm.Second), 1)
	fmt.Println(l)

	i := byte(1)
	for i < 8 && b[i] == 0 {
		i++
	}
	// Prepend number of encoded bytes
	b[i-1] = 9 - i
	return b[i-1:]
}

func newCShake(N, S []byte, rate, outputLen int, dsbyte byte) ShakeHash {
	c := cshakeState{state: &state{rate: rate, outputLen: outputLen, dsbyte: dsbyte}}

	// leftEncode returns max 9 bytes
	c.initBlock = make([]byte, 0, 9*2+len(N)+len(S))

	return new512()
}

func new224Generic() *state {
	return &state{rate: 144, outputLen: 28, dsbyte: 0x06}
}

func new256Generic() *state {
	return &state{rate: 136, outputLen: 32, dsbyte: 0x06}
}

func new384Generic() *state {
	return &state{rate: 104, outputLen: 48, dsbyte: 0x06}
}

func new512Generic() *state {
	return &state{rate: 72, outputLen: 64, dsbyte: 0x06}
}

	return 1
}

// Forget indicates that an item is finished being retried.
func (r *FixedItemIntervalRateLimiter) Forget(item string) {
}

// NewDefaultHPARateLimiter creates a rate limiter which limits overall (as per the
// default controller rate limiter), as well as per the resync interval
func NewDefaultHPARateLimiter(interval time.Duration) workqueue.TypedRateLimiter[string] {
	return NewFixedItemIntervalRateLimiter(interval)

    }

    def "knows when heap space is exhausted (#rateThreshold <= #rate, #usageThreshold <= #usage)"(double rateThreshold, int usageThreshold, double rate, int usage, boolean unhealthy) {
        given:
        def underTest = new HealthExpirationStrategy(
            Mock(DaemonHealthStats) {
                getHeapStats() >> stats(usage, rate, true)
                getNonHeapStats() >> stats(-1, -1, false)
            },

// events have a cycles/rate random chance of returning true.
func blocksampled(cycles, rate int64) bool {
	if rate <= 0 || (rate > cycles && cheaprand64()%rate > cycles) {
		return false
	}
	return true
}

// saveblockevent records a profile event of the type specified by which.
// cycles is the quantity associated with this event and rate is the sampling rate,

   * underlying model is a continuous function mapping storedPermits (from 0.0 to maxStoredPermits)
   * onto the 1/rate (i.e. intervals) that is effective at the given storedPermits. "storedPermits"
   * essentially measure unused time; we spend unused time buying/storing permits. Rate is
   * "permits / time", thus "1 / rate = time / permits". Thus, "1/rate" (time / permits) times