theine

package
v0.19.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 3, 2024 License: Apache-2.0, MIT Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NEW int8 = iota
	REMOVE
	UPDATE
)
View Source 
const (
	LIST_PROBATION uint8 = 1
	LIST_PROTECTED uint8 = 2
)
View Source 
const (
	MaxReadBuffSize  = 64
	MinWriteBuffSize = 4
	MaxWriteBuffSize = 1024
)

Variables

This section is empty.

Functions

This section is empty.

Types

type CountMinSketch 

type CountMinSketch struct {
	Table      []uint64
	Additions  uint
	SampleSize uint
	BlockMask  uint
}

func NewCountMinSketch 

func NewCountMinSketch() *CountMinSketch

func (*CountMinSketch) Add 

func (s *CountMinSketch) Add(h uint64) bool

func (*CountMinSketch) EnsureCapacity 

func (s *CountMinSketch) EnsureCapacity(size uint)

func (*CountMinSketch) Estimate 

func (s *CountMinSketch) Estimate(h uint64) uint

type Entry 

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

func NewEntry 

func NewEntry[K cachekey, V any](key K, value V, cost int64) *Entry[K, V]

func (*Entry[K, V]) Next 

func (e *Entry[K, V]) Next() *Entry[K, V]

func (*Entry[K, V]) Prev 

func (e *Entry[K, V]) Prev() *Entry[K, V]

type Group 

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

Group represents a class of work and forms a namespace in which units of work can be executed with duplicate suppression.

func NewGroup 

func NewGroup[K comparable, V any]() *Group[K, V]

func (*Group[K, V]) Do 

func (g *Group[K, V]) Do(key K, fn func() (V, error)) (v V, err error, shared bool)

Do executes and returns the results of the given function, making sure that only one execution is in-flight for a given key at a time. If a duplicate comes in, the duplicate caller waits for the original to complete and receives the same results. The return value shared indicates whether v was given to multiple callers.

type HashKey256 

type HashKey256 [32]byte

func (HashKey256) Hash 

func (h HashKey256) Hash() uint64

func (HashKey256) Hash2 

func (h HashKey256) Hash2() (uint64, uint64)

type List 

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

List represents a doubly linked list. The zero value for List is an empty list ready to use.

func NewList 

func NewList[K cachekey, V any](size uint, listType uint8) *List[K, V]

New returns an initialized list.

func (*List[K, V]) Back 

func (l *List[K, V]) Back() *Entry[K, V]

Back returns the last element of list l or nil if the list is empty.

func (*List[K, V]) Contains 

func (l *List[K, V]) Contains(entry *Entry[K, V]) bool

func (*List[K, V]) Front 

func (l *List[K, V]) Front() *Entry[K, V]

Front returns the first element of list l or nil if the list is empty.

func (*List[K, V]) Len 

func (l *List[K, V]) Len() int

Len returns the number of elements of list l. The complexity is O(1).

func (*List[K, V]) MoveAfter 

func (l *List[K, V]) MoveAfter(e, mark *Entry[K, V])

MoveAfter moves element e to its new position after mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

func (*List[K, V]) MoveBefore 

func (l *List[K, V]) MoveBefore(e, mark *Entry[K, V])

MoveBefore moves element e to its new position before mark. If e or mark is not an element of l, or e == mark, the list is not modified. The element and mark must not be nil.

func (*List[K, V]) MoveToBack 

func (l *List[K, V]) MoveToBack(e *Entry[K, V])

MoveToBack moves element e to the back of list l. If e is not an element of l, the list is not modified. The element must not be nil.

func (*List[K, V]) MoveToFront 

func (l *List[K, V]) MoveToFront(e *Entry[K, V])

MoveToFront moves element e to the front of list l. If e is not an element of l, the list is not modified. The element must not be nil.

func (*List[K, V]) PopTail 

func (l *List[K, V]) PopTail() *Entry[K, V]

func (*List[K, V]) PushBack 

func (l *List[K, V]) PushBack(e *Entry[K, V]) *Entry[K, V]

Push push entry to the back of list

func (*List[K, V]) PushFront 

func (l *List[K, V]) PushFront(e *Entry[K, V]) *Entry[K, V]

PushFront push entry to list head

func (*List[K, V]) Remove 

func (l *List[K, V]) Remove(e *Entry[K, V])

Remove removes e from l if e is an element of list l. It returns the element value e.Value. The element must not be nil.

func (*List[K, V]) Reset 

func (l *List[K, V]) Reset()

type MetaData 

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

type Metrics 

type Metrics struct {
	// contains filtered or unexported fields
}

func (*Metrics) Accesses 

func (m *Metrics) Accesses() int64

func (*Metrics) Evicted 

func (m *Metrics) Evicted() int64

func (*Metrics) Hits 

func (m *Metrics) Hits() int64

func (*Metrics) Misses 

func (m *Metrics) Misses() int64

type Queue 

type Queue[V any] struct {
	// contains filtered or unexported fields
}

func NewQueue 

func NewQueue[V any]() *Queue[V]

func (*Queue[V]) Empty 

func (q *Queue[V]) Empty() bool

Empty returns true if the queue is empty

Empty must be called from a single, consumer goroutine

func (*Queue[V]) Pop 

func (q *Queue[V]) Pop() (V, bool)

Pop removes the item from the front of the queue or nil if the queue is empty

Pop must be called from a single, consumer goroutine

func (*Queue[V]) Push 

func (q *Queue[V]) Push(x V)

Push adds x to the back of the queue.

Push can be safely called from multiple goroutines

type ReadBufItem 

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

type RemoveReason 

type RemoveReason uint8
const (
	REMOVED RemoveReason = iota
	EVICTED
	EXPIRED
)

type Result 

type Result struct {
	Val    interface{}
	Err    error
	Shared bool
}

Result holds the results of Do, so they can be passed on a channel.

type Shard 

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

func NewShard 

func NewShard[K cachekey, V any](qsize uint, doorkeeper bool) *Shard[K, V]

type Slru 

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

func NewSlru 

func NewSlru[K cachekey, V any](size uint) *Slru[K, V]

type Store 

type Store[K cachekey, V cacheval] struct {
	Metrics   Metrics
	OnRemoval func(K, V, RemoveReason)
	// contains filtered or unexported fields
}

func NewStore 

func NewStore[K cachekey, V cacheval](maxsize int64, doorkeeper bool) *Store[K, V]

func (*Store[K, V]) Close 

func (s *Store[K, V]) Close()

func (*Store[K, V]) Delete 

func (s *Store[K, V]) Delete(key K)

func (*Store[K, V]) EnsureOpen 

func (s *Store[K, V]) EnsureOpen()

func (*Store[K, V]) Get 

func (s *Store[K, V]) Get(key K, epoch uint32) (V, bool)

func (*Store[K, V]) GetOrLoad 

func (s *Store[K, V]) GetOrLoad(key K, epoch uint32, load func() (V, error)) (V, bool, error)

func (*Store[K, V]) Len 

func (s *Store[K, V]) Len() int

func (*Store[K, V]) MaxCapacity 

func (s *Store[K, V]) MaxCapacity() int

func (*Store[K, V]) Range 

func (s *Store[K, V]) Range(epoch uint32, f func(key K, value V) bool)

func (*Store[K, V]) Set 

func (s *Store[K, V]) Set(key K, value V, cost int64, epoch uint32) bool

func (*Store[K, V]) UsedCapacity 

func (s *Store[K, V]) UsedCapacity() int

type StringKey 

type StringKey string

func (StringKey) Hash 

func (h StringKey) Hash() uint64

func (StringKey) Hash2 

func (h StringKey) Hash2() (uint64, uint64)

type TinyLfu 

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

func NewTinyLfu 

func NewTinyLfu[K cachekey, V any](size uint) *TinyLfu[K, V]

func (*TinyLfu[K, V]) Access 

func (t *TinyLfu[K, V]) Access(item ReadBufItem[K, V])

func (*TinyLfu[K, V]) EvictEntries 

func (t *TinyLfu[K, V]) EvictEntries() []*Entry[K, V]

func (*TinyLfu[K, V]) Remove 

func (t *TinyLfu[K, V]) Remove(entry *Entry[K, V])

func (*TinyLfu[K, V]) Set 

func (t *TinyLfu[K, V]) Set(entry *Entry[K, V]) *Entry[K, V]

func (*TinyLfu[K, V]) UpdateCost 

func (t *TinyLfu[K, V]) UpdateCost(entry *Entry[K, V], delta int64)

func (*TinyLfu[K, V]) UpdateThreshold 

func (t *TinyLfu[K, V]) UpdateThreshold()

type WriteBufItem 

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

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.