Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 expirable_lru.go // Copyright (c) HashiCorp, Inc. // SPDX-License-Identifier: MPL-2.0 package expirable import ( "sync" "time" "github.com/hashicorp/golang-lru/v2/internal" ) // EvictCallback is used to get a callback when a cache entry is evicted type EvictCallback[K comparable, V any] func(key K, value V) // LRU implements a thread-safe LRU with expirable entries. type LRU[K comparable, V any] struct { size int evictList internal.LruList[K, V] items map[K]internal.Entry[K, V] onEvict EvictCallback[K, V] // expirable options mu sync.Mutex ttl time.Duration done chan struct{} // buckets for expiration buckets []bucket[K, V] // uint8 because it's number between 0 and numBuckets nextCleanupBucket uint8 } // bucket is a container for holding entries to be expired type bucket[K comparable, V any] struct { entries map[K]internal.Entry[K, V] newestEntry time.Time } // noEvictionTTL - very long ttl to prevent eviction const noEvictionTTL = time.Hour 24 * 365 * 10 // because of uint8 usage for nextCleanupBucket, should not exceed 256. // casting it as uint8 explicitly requires type conversions in multiple places const numBuckets = 100 // NewLRU returns a new thread-safe cache with expirable entries. // // Size parameter set to 0 makes cache of unlimited size, e.g. turns LRU mechanism off. // // Providing 0 TTL turns expiring off. // // Delete expired entries every 1/100th of ttl value. Goroutine which deletes expired entries runs indefinitely. func NewLRU[K comparable, V any](size int, onEvict EvictCallback[K, V], ttl time.Duration) LRU[K, V] { if size < 0 { size = 0 } if ttl <= 0 { ttl = noEvictionTTL } res := LRU[K, V]{ ttl: ttl, size: size, evictList: internal.NewList[K, V](), items: make(map[K]internal.Entry[K, V]), onEvict: onEvict, done: make(chan struct{}), } // initialize the buckets res.buckets = make([]bucket[K, V], numBuckets) for i := 0; i < numBuckets; i++ { res.buckets[i] = bucket[K, V]{entries: make(map[K]internal.Entry[K, V])} } // enable deleteExpired() running in separate goroutine for cache with non-zero TTL // // Important: done channel is never closed, so deleteExpired() goroutine will never exit, // it's decided to add functionality to close it in the version later than v2. if res.ttl != noEvictionTTL { go func(done <-chan struct{}) { ticker := time.NewTicker(res.ttl / numBuckets) defer ticker.Stop() for { select { case <-done: return case <-ticker.C: res.deleteExpired() } } }(res.done) } return &res } // Purge clears the cache completely. // onEvict is called for each evicted key. func (c LRU[K, V]) Purge() { c.mu.Lock() defer c.mu.Unlock() for k, v := range c.items { if c.onEvict != nil { c.onEvict(k, v.Value) } delete(c.items, k) } for _, b := range c.buckets { for _, ent := range b.entries { delete(b.entries, ent.Key) } } c.evictList.Init() } // Add adds a value to the cache. Returns true if an eviction occurred. // Returns false if there was no eviction: the item was already in the cache, // or the size was not exceeded. func (c LRU[K, V]) Add(key K, value V) (evicted bool) { c.mu.Lock() defer c.mu.Unlock() now := time.Now() // Check for existing item if ent, ok := c.items[key]; ok { c.evictList.MoveToFront(ent) c.removeFromBucket(ent) // remove the entry from its current bucket as expiresAt is renewed ent.Value = value ent.ExpiresAt = now.Add(c.ttl) c.addToBucket(ent) return false } // Add new item ent := c.evictList.PushFrontExpirable(key, value, now.Add(c.ttl)) c.items[key] = ent c.addToBucket(ent) // adds the entry to the appropriate bucket and sets entry.expireBucket evict := c.size > 0 && c.evictList.Length() > c.size // Verify size not exceeded if evict { c.removeOldest() } return evict } // Get looks up a key's value from the cache. func (c LRU[K, V]) Get(key K) (value V, ok bool) { c.mu.Lock() defer c.mu.Unlock() var ent internal.Entry[K, V] if ent, ok = c.items[key]; ok { // Expired item check if time.Now().After(ent.ExpiresAt) { return value, false } c.evictList.MoveToFront(ent) return ent.Value, true } return } // Contains checks if a key is in the cache, without updating the recent-ness // or deleting it for being stale. func (c LRU[K, V]) Contains(key K) (ok bool) { c.mu.Lock() defer c.mu.Unlock() _, ok = c.items[key] return ok } // Peek returns the key value (or undefined if not found) without updating // the "recently used"-ness of the key. func (c LRU[K, V]) Peek(key K) (value V, ok bool) { c.mu.Lock() defer c.mu.Unlock() var ent internal.Entry[K, V] if ent, ok = c.items[key]; ok { // Expired item check if time.Now().After(ent.ExpiresAt) { return value, false } return ent.Value, true } return } // Remove removes the provided key from the cache, returning if the // key was contained. func (c LRU[K, V]) Remove(key K) bool { c.mu.Lock() defer c.mu.Unlock() if ent, ok := c.items[key]; ok { c.removeElement(ent) return true } return false } // RemoveOldest removes the oldest item from the cache. func (c LRU[K, V]) RemoveOldest() (key K, value V, ok bool) { c.mu.Lock() defer c.mu.Unlock() if ent := c.evictList.Back(); ent != nil { c.removeElement(ent) return ent.Key, ent.Value, true } return } // GetOldest returns the oldest entry func (c LRU[K, V]) GetOldest() (key K, value V, ok bool) { c.mu.Lock() defer c.mu.Unlock() if ent := c.evictList.Back(); ent != nil { return ent.Key, ent.Value, true } return } // Keys returns a slice of the keys in the cache, from oldest to newest. func (c LRU[K, V]) Keys() []K { c.mu.Lock() defer c.mu.Unlock() keys := make([]K, 0, len(c.items)) for ent := c.evictList.Back(); ent != nil; ent = ent.PrevEntry() { keys = append(keys, ent.Key) } return keys } // Values returns a slice of the values in the cache, from oldest to newest. // Expired entries are filtered out. func (c LRU[K, V]) Values() []V { c.mu.Lock() defer c.mu.Unlock() values := make([]V, len(c.items)) i := 0 now := time.Now() for ent := c.evictList.Back(); ent != nil; ent = ent.PrevEntry() { if now.After(ent.ExpiresAt) { continue } values[i] = ent.Value i++ } return values } // Len returns the number of items in the cache. func (c LRU[K, V]) Len() int { c.mu.Lock() defer c.mu.Unlock() return c.evictList.Length() } // Resize changes the cache size. Size of 0 means unlimited. func (c LRU[K, V]) Resize(size int) (evicted int) { c.mu.Lock() defer c.mu.Unlock() if size <= 0 { c.size = 0 return 0 } diff := c.evictList.Length() - size if diff < 0 { diff = 0 } for i := 0; i < diff; i++ { c.removeOldest() } c.size = size return diff } // Close destroys cleanup goroutine. To clean up the cache, run Purge() before Close(). // func (c LRU[K, V]) Close() { // c.mu.Lock() // defer c.mu.Unlock() // select { // case <-c.done: // return // default: // } // close(c.done) // } // removeOldest removes the oldest item from the cache. Has to be called with lock! func (c LRU[K, V]) removeOldest() { if ent := c.evictList.Back(); ent != nil { c.removeElement(ent) } } // removeElement is used to remove a given list element from the cache. Has to be called with lock! func (c LRU[K, V]) removeElement(e internal.Entry[K, V]) { c.evictList.Remove(e) delete(c.items, e.Key) c.removeFromBucket(e) if c.onEvict != nil { c.onEvict(e.Key, e.Value) } } // deleteExpired deletes expired records from the oldest bucket, waiting for the newest entry // in it to expire first. func (c LRU[K, V]) deleteExpired() { c.mu.Lock() bucketIdx := c.nextCleanupBucket timeToExpire := time.Until(c.buckets[bucketIdx].newestEntry) // wait for newest entry to expire before cleanup without holding lock if timeToExpire > 0 { c.mu.Unlock() time.Sleep(timeToExpire) c.mu.Lock() } for _, ent := range c.buckets[bucketIdx].entries { c.removeElement(ent) } c.nextCleanupBucket = (c.nextCleanupBucket + 1) % numBuckets c.mu.Unlock() } // addToBucket adds entry to expire bucket so that it will be cleaned up when the time comes. Has to be called with lock! func (c LRU[K, V]) addToBucket(e internal.Entry[K, V]) { bucketID := (numBuckets + c.nextCleanupBucket - 1) % numBuckets e.ExpireBucket = bucketID c.buckets[bucketID].entries[e.Key] = e if c.buckets[bucketID].newestEntry.Before(e.ExpiresAt) { c.buckets[bucketID].newestEntry = e.ExpiresAt } } // removeFromBucket removes the entry from its corresponding bucket. Has to be called with lock! func (c LRU[K, V]) removeFromBucket(e internal.Entry[K, V]) { delete(c.buckets[e.ExpireBucket].entries, e.Key) }	8.54 KB	2025-05-25 12:27
📄 expirable_lru_test.go // Copyright (c) HashiCorp, Inc. // SPDX-License-Identifier: MPL-2.0 package expirable import ( "crypto/rand" "fmt" "math" "math/big" "reflect" "sync" "testing" "time" "github.com/hashicorp/golang-lru/v2/simplelru" ) func BenchmarkLRU_Rand_NoExpire(b testing.B) { l := NewLRU[int64, int64](8192, nil, 0) trace := make([]int64, b.N2) for i := 0; i < b.N2; i++ { trace[i] = getRand(b) % 32768 } b.ResetTimer() var hit, miss int for i := 0; i < 2b.N; i++ { if i%2 == 0 { l.Add(trace[i], trace[i]) } else { if _, ok := l.Get(trace[i]); ok { hit++ } else { miss++ } } } b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(hit+miss)) } func BenchmarkLRU_Freq_NoExpire(b testing.B) { l := NewLRU[int64, int64](8192, nil, 0) trace := make([]int64, b.N2) for i := 0; i < b.N2; i++ { if i%2 == 0 { trace[i] = getRand(b) % 16384 } else { trace[i] = getRand(b) % 32768 } } b.ResetTimer() for i := 0; i < b.N; i++ { l.Add(trace[i], trace[i]) } var hit, miss int for i := 0; i < b.N; i++ { if _, ok := l.Get(trace[i]); ok { hit++ } else { miss++ } } b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(hit+miss)) } func BenchmarkLRU_Rand_WithExpire(b testing.B) { l := NewLRU[int64, int64](8192, nil, time.Millisecond10) trace := make([]int64, b.N2) for i := 0; i < b.N2; i++ { trace[i] = getRand(b) % 32768 } b.ResetTimer() var hit, miss int for i := 0; i < 2b.N; i++ { if i%2 == 0 { l.Add(trace[i], trace[i]) } else { if _, ok := l.Get(trace[i]); ok { hit++ } else { miss++ } } } b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(hit+miss)) } func BenchmarkLRU_Freq_WithExpire(b testing.B) { l := NewLRU[int64, int64](8192, nil, time.Millisecond10) trace := make([]int64, b.N2) for i := 0; i < b.N2; i++ { if i%2 == 0 { trace[i] = getRand(b) % 16384 } else { trace[i] = getRand(b) % 32768 } } b.ResetTimer() for i := 0; i < b.N; i++ { l.Add(trace[i], trace[i]) } var hit, miss int for i := 0; i < b.N; i++ { if _, ok := l.Get(trace[i]); ok { hit++ } else { miss++ } } b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(hit+miss)) } func TestLRUInterface(_ testing.T) { var _ simplelru.LRUCache[int, int] = &LRU[int, int]{} } func TestLRUNoPurge(t testing.T) { lc := NewLRU[string, string](10, nil, 0) lc.Add("key1", "val1") if lc.Len() != 1 { t.Fatalf("length differs from expected") } v, ok := lc.Peek("key1") if v != "val1" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } if !lc.Contains("key1") { t.Fatalf("should contain key1") } if lc.Contains("key2") { t.Fatalf("should not contain key2") } v, ok = lc.Peek("key2") if v != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) { t.Fatalf("value differs from expected") } if lc.Resize(0) != 0 { t.Fatalf("evicted count differs from expected") } if lc.Resize(2) != 0 { t.Fatalf("evicted count differs from expected") } lc.Add("key2", "val2") if lc.Resize(1) != 1 { t.Fatalf("evicted count differs from expected") } } func TestLRUEdgeCases(t testing.T) { lc := NewLRU[string, string](2, nil, 0) // Adding a nil value lc.Add("key1", nil) value, exists := lc.Get("key1") if value != nil \|\| !exists { t.Fatalf("unexpected value or existence flag for key1: value=%v, exists=%v", value, exists) } // Adding an entry with the same key but different value newVal := "val1" lc.Add("key1", &newVal) value, exists = lc.Get("key1") if value != &newVal \|\| !exists { t.Fatalf("unexpected value or existence flag for key1: value=%v, exists=%v", value, exists) } } func TestLRU_Values(t testing.T) { lc := NewLRU[string, string](3, nil, 0) lc.Add("key1", "val1") lc.Add("key2", "val2") lc.Add("key3", "val3") values := lc.Values() if !reflect.DeepEqual(values, []string{"val1", "val2", "val3"}) { t.Fatalf("values differs from expected") } } // func TestExpirableMultipleClose(_ testing.T) { // lc := NewLRU[string, string](10, nil, 0) // lc.Close() // // should not panic // lc.Close() // } func TestLRUWithPurge(t testing.T) { var evicted []string lc := NewLRU(10, func(key string, value string) { evicted = append(evicted, key, value) }, 150time.Millisecond) k, v, ok := lc.GetOldest() if k != "" { t.Fatalf("should be empty") } if v != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } lc.Add("key1", "val1") time.Sleep(100 * time.Millisecond) // not enough to expire if lc.Len() != 1 { t.Fatalf("length differs from expected") } v, ok = lc.Get("key1") if v != "val1" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } time.Sleep(200 * time.Millisecond) // expire v, ok = lc.Get("key1") if ok { t.Fatalf("should be false") } if v != "" { t.Fatalf("should be nil") } if lc.Len() != 0 { t.Fatalf("length differs from expected") } if !reflect.DeepEqual(evicted, []string{"key1", "val1"}) { t.Fatalf("value differs from expected") } // add new entry lc.Add("key2", "val2") if lc.Len() != 1 { t.Fatalf("length differs from expected") } k, v, ok = lc.GetOldest() if k != "key2" { t.Fatalf("value differs from expected") } if v != "val2" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } // DeleteExpired, nothing deleted lc.deleteExpired() if lc.Len() != 1 { t.Fatalf("length differs from expected") } if !reflect.DeepEqual(evicted, []string{"key1", "val1"}) { t.Fatalf("value differs from expected") } // Purge, cache should be clean lc.Purge() if lc.Len() != 0 { t.Fatalf("length differs from expected") } if !reflect.DeepEqual(evicted, []string{"key1", "val1", "key2", "val2"}) { t.Fatalf("value differs from expected") } } func TestLRUWithPurgeEnforcedBySize(t testing.T) { lc := NewLRU[string, string](10, nil, time.Hour) for i := 0; i < 100; i++ { i := i lc.Add(fmt.Sprintf("key%d", i), fmt.Sprintf("val%d", i)) v, ok := lc.Get(fmt.Sprintf("key%d", i)) if v != fmt.Sprintf("val%d", i) { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } if lc.Len() > 20 { t.Fatalf("length should be less than 20") } } if lc.Len() != 10 { t.Fatalf("length differs from expected") } } func TestLRUConcurrency(t testing.T) { lc := NewLRU[string, string](0, nil, 0) wg := sync.WaitGroup{} wg.Add(1000) for i := 0; i < 1000; i++ { go func(i int) { lc.Add(fmt.Sprintf("key-%d", i/10), fmt.Sprintf("val-%d", i/10)) wg.Done() }(i) } wg.Wait() if lc.Len() != 100 { t.Fatalf("length differs from expected") } } func TestLRUInvalidateAndEvict(t testing.T) { var evicted int lc := NewLRU(-1, func(_, _ string) { evicted++ }, 0) lc.Add("key1", "val1") lc.Add("key2", "val2") val, ok := lc.Get("key1") if !ok { t.Fatalf("should be true") } if val != "val1" { t.Fatalf("value differs from expected") } if evicted != 0 { t.Fatalf("value differs from expected") } lc.Remove("key1") if evicted != 1 { t.Fatalf("value differs from expected") } val, ok = lc.Get("key1") if val != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } } func TestLoadingExpired(t testing.T) { lc := NewLRU[string, string](0, nil, time.Millisecond5) lc.Add("key1", "val1") if lc.Len() != 1 { t.Fatalf("length differs from expected") } v, ok := lc.Peek("key1") if v != "val1" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } v, ok = lc.Get("key1") if v != "val1" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } for { result, ok := lc.Get("key1") if ok && result == "" { t.Fatalf("ok should return a result") } if !ok { break } } time.Sleep(time.Millisecond 100) // wait for expiration reaper if lc.Len() != 0 { t.Fatalf("length differs from expected") } v, ok = lc.Peek("key1") if v != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } v, ok = lc.Get("key1") if v != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } } func TestLRURemoveOldest(t testing.T) { lc := NewLRU[string, string](2, nil, 0) k, v, ok := lc.RemoveOldest() if k != "" { t.Fatalf("should be empty") } if v != "" { t.Fatalf("should be empty") } if ok { t.Fatalf("should be false") } ok = lc.Remove("non_existent") if ok { t.Fatalf("should be false") } lc.Add("key1", "val1") if lc.Len() != 1 { t.Fatalf("length differs from expected") } v, ok = lc.Get("key1") if !ok { t.Fatalf("should be true") } if v != "val1" { t.Fatalf("value differs from expected") } if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) { t.Fatalf("value differs from expected") } if lc.Len() != 1 { t.Fatalf("length differs from expected") } lc.Add("key2", "val2") if !reflect.DeepEqual(lc.Keys(), []string{"key1", "key2"}) { t.Fatalf("value differs from expected") } if lc.Len() != 2 { t.Fatalf("length differs from expected") } k, v, ok = lc.RemoveOldest() if k != "key1" { t.Fatalf("value differs from expected") } if v != "val1" { t.Fatalf("value differs from expected") } if !ok { t.Fatalf("should be true") } if !reflect.DeepEqual(lc.Keys(), []string{"key2"}) { t.Fatalf("value differs from expected") } if lc.Len() != 1 { t.Fatalf("length differs from expected") } } func ExampleLRU() { // make cache with 10ms TTL and 5 max keys cache := NewLRU[string, string](5, nil, time.Millisecond10) // set value under key1. cache.Add("key1", "val1") // get value under key1 r, ok := cache.Get("key1") // check for OK value if ok { fmt.Printf("value before expiration is found: %v, value: %q\n", ok, r) } // wait for cache to expire time.Sleep(time.Millisecond * 100) // get value under key1 after key expiration r, ok = cache.Get("key1") fmt.Printf("value after expiration is found: %v, value: %q\n", ok, r) // set value under key2, would evict old entry because it is already expired. cache.Add("key2", "val2") fmt.Printf("Cache len: %d\n", cache.Len()) // Output: // value before expiration is found: true, value: "val1" // value after expiration is found: false, value: "" // Cache len: 1 } func getRand(tb testing.TB) int64 { out, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64)) if err != nil { tb.Fatal(err) } return out.Int64() } func (c LRU[K, V]) wantKeys(t testing.T, want []K) { t.Helper() got := c.Keys() if !reflect.DeepEqual(got, want) { t.Errorf("wrong keys got: %v, want: %v ", got, want) } } func TestCache_EvictionSameKey(t *testing.T) { var evictedKeys []int cache := NewLRU[int, struct{}]( 2, func(key int, _ struct{}) { evictedKeys = append(evictedKeys, key) }, 0) if evicted := cache.Add(1, struct{}{}); evicted { t.Error("First 1: got unexpected eviction") } cache.wantKeys(t, []int{1}) if evicted := cache.Add(2, struct{}{}); evicted { t.Error("2: got unexpected eviction") } cache.wantKeys(t, []int{1, 2}) if evicted := cache.Add(1, struct{}{}); evicted { t.Error("Second 1: got unexpected eviction") } cache.wantKeys(t, []int{2, 1}) if evicted := cache.Add(3, struct{}{}); !evicted { t.Error("3: did not get expected eviction") } cache.wantKeys(t, []int{1, 3}) want := []int{2} if !reflect.DeepEqual(evictedKeys, want) { t.Errorf("evictedKeys got: %v want: %v", evictedKeys, want) } }	11.42 KB	2025-05-25 12:27

Terminal