clock

type Cache ¶

type Cache[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Cache is used The clock cache replacement policy.

The clock algorithm keeps a circular list of pages in memory, with the "hand" (iterator) pointing to the last examined page frame in the list. When a page fault occurs and no empty frames exist, then the R (referenced) bit is inspected at the hand's location. If R is 0, the new page is put in place of the page the "hand" points to, and the hand is advanced one position. Otherwise, the R bit is cleared, then the clock hand is incremented and the process is repeated until a page is replaced.

func NewCache[K comparable, V any](opts ...Option) *Cache[K, V]

package main

import (
	"fmt"

	"github.com/xuxife/go-generics-cache/policy/clock"
)

func main() {
	c := clock.NewCache[string, int]()
	c.Set("a", 1)
	c.Set("b", 2)
	av, aok := c.Get("a")
	bv, bok := c.Get("b")
	cv, cok := c.Get("c")
	fmt.Println(av, aok)
	fmt.Println(bv, bok)
	fmt.Println(cv, cok)
	c.Delete("a")
	_, aok2 := c.Get("a")
	if !aok2 {
		fmt.Println("key 'a' has been deleted")
	}
	// update
	c.Set("b", 3)
	newbv, _ := c.Get("b")
	fmt.Println(newbv)
}

Output:

1 true
2 true
0 false
key 'a' has been deleted
3

func (c *Cache[K, V]) Delete(key K)

func (c *Cache[K, V]) Get(key K) (zero V, _ bool)

func (c *Cache[K, V]) Keys() []K

package main

import (
	"fmt"

	"github.com/xuxife/go-generics-cache/policy/clock"
)

func main() {
	c := clock.NewCache[string, int]()
	c.Set("foo", 1)
	c.Set("bar", 2)
	c.Set("baz", 3)
	keys := c.Keys()
	for _, key := range keys {
		fmt.Println(key)
	}
}

Output:

foo
bar
baz

func (c *Cache[K, V]) Len() int

func (c *Cache[K, V]) Set(key K, val V)

type Option ¶

type Option func(*options)

Option is an option for clock cache.

func WithCapacity(cap int) Option