cache

Documentation

Index

• Variables
• type Cache
  • func NewCache(size int, cacheType Type) Cache
  • func NewDefaultCache(size int) Cache
• type FIFO
  • func NewFIFO(maxCount int) *FIFO
  • func (c *FIFO) Elems() []*Item
  • func (c *FIFO) FromElems(key uint64) []*Item
  • func (c *FIFO) Len() int
  • func (c *FIFO) Put(key uint64, value interface{})
  • func (c *FIFO) Remove()
• type Item
• type LRU
  • func (c *LRU) Elems() []*Item
  • func (c *LRU) Get(key uint64) (interface{}, bool)
  • func (c *LRU) Len() int
  • func (c *LRU) Peek(key uint64) (interface{}, bool)
  • func (c *LRU) Put(key uint64, value interface{})
  • func (c *LRU) Remove(key uint64)
• type TTL
  • func NewTTL(ctx context.Context, gcInterval time.Duration, ttl time.Duration) *TTL
  • func (c *TTL) Clear()
  • func (c *TTL) Get(key uint64) (interface{}, bool)
  • func (c *TTL) Len() int
  • func (c *TTL) Put(key uint64, value interface{})
  • func (c *TTL) PutWithTTL(key uint64, value interface{}, ttl time.Duration)
  • func (c *TTL) Remove(key uint64)
• type TTLUint64
  • func NewIDTTL(ctx context.Context, gcInterval, ttl time.Duration) *TTLUint64
  • func (c *TTLUint64) Exists(id uint64) bool
  • func (c *TTLUint64) Put(id uint64)
• type TwoQueue
  • func (c *TwoQueue) Elems() []*Item
  • func (c *TwoQueue) Get(key uint64) (interface{}, bool)
  • func (c *TwoQueue) Len() int
  • func (c *TwoQueue) Peek(key uint64) (interface{}, bool)
  • func (c *TwoQueue) Put(key uint64, value interface{})
  • func (c *TwoQueue) Remove(key uint64)
• type Type

Variables

var (
	// DefaultCacheType set default cache type for NewDefaultCache function
	DefaultCacheType = LRUCache
)

Types

type Cache

type Cache interface {
	// Put puts an item into cache.
	Put(key uint64, value interface{})
	// Get retrives an item from cache.
	Get(key uint64) (interface{}, bool)
	// Peek reads an item from cache. The action is no considered 'Use'.
	Peek(key uint64) (interface{}, bool)
	// Remove eliminates an item from cache.
	Remove(key uint64)
	// Elems return all items in cache.
	Elems() []*Item
	// Len returns current cache size
	Len() int
}

Cache is an interface for cache system

func NewCache

func NewCache(size int, cacheType Type) Cache

NewCache create Cache instance by CacheType

func NewDefaultCache

func NewDefaultCache(size int) Cache

NewDefaultCache create Cache instance by default cache type

type FIFO

type FIFO struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

FIFO is 'First-In-First-Out' cache.

func NewFIFO

func NewFIFO(maxCount int) *FIFO

NewFIFO returns a new FIFO cache.

func (*FIFO) Elems

func (c *FIFO) Elems() []*Item

Elems returns all items in cache.

func (*FIFO) FromElems

func (c *FIFO) FromElems(key uint64) []*Item

FromElems returns all items that has a key greater than the specified one.

func (*FIFO) Len

func (c *FIFO) Len() int

Len returns current cache size.

func (*FIFO) Put

func (c *FIFO) Put(key uint64, value interface{})

Put puts an item into cache.

func (*FIFO) Remove

func (c *FIFO) Remove()

Remove takes the oldest item out.

type Item

type Item struct {
	Key   uint64
	Value interface{}
}

Item is the cache entry.

type LRU

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

LRU is 'Least-Recently-Used' cache.

func (*LRU) Elems

func (c *LRU) Elems() []*Item

Elems return all items in cache.

func (*LRU) Get

func (c *LRU) Get(key uint64) (interface{}, bool)

Get retrives an item from cache.

func (*LRU) Len

func (c *LRU) Len() int

Len returns current cache size.

func (*LRU) Peek

func (c *LRU) Peek(key uint64) (interface{}, bool)

Peek reads an item from cache. The action is no considered 'Use'.

func (*LRU) Put

func (c *LRU) Put(key uint64, value interface{})

Put puts an item into cache.

func (*LRU) Remove

func (c *LRU) Remove(key uint64)

Remove eliminates an item from cache.

type TTL

type TTL struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

TTL is a cache that assigns TTL(Time-To-Live) for each items.

func NewTTL

func NewTTL(ctx context.Context, gcInterval time.Duration, ttl time.Duration) *TTL

NewTTL returns a new TTL cache.

func (*TTL) Clear

func (c *TTL) Clear()

Clear removes all items in the ttl cache.

func (*TTL) Get

func (c *TTL) Get(key uint64) (interface{}, bool)

Get retrives an item from cache.

func (*TTL) Len

func (c *TTL) Len() int

Len returns current cache size.

func (*TTL) Put

func (c *TTL) Put(key uint64, value interface{})

Put puts an item into cache.

func (*TTL) PutWithTTL

func (c *TTL) PutWithTTL(key uint64, value interface{}, ttl time.Duration)

PutWithTTL puts an item into cache with specified TTL.

func (*TTL) Remove

func (c *TTL) Remove(key uint64)

Remove eliminates an item from cache.

type TTLUint64

type TTLUint64 struct {
	*TTL
}

TTLUint64 is simple TTL saves only uint64s.

func NewIDTTL

func NewIDTTL(ctx context.Context, gcInterval, ttl time.Duration) *TTLUint64

NewIDTTL creates a new TTLUint64 cache.

func (*TTLUint64) Exists

func (c *TTLUint64) Exists(id uint64) bool

Exists checks if an ID exists in cache.

func (*TTLUint64) Put

func (c *TTLUint64) Put(id uint64)

Put saves an ID in cache.

type TwoQueue

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

TwoQueue is a fixed size 2Q cache. 2Q is an enhancement over the standard LRU cache in that it tracks both frequently and recently used entries separately. This avoids a burst in access to new entries from evicting frequently used entries. It adds some additional tracking overhead to the standard LRU cache, and is computationally about 2x the cost, and adds some metadata over head. The ARCCache is similar, but does not require setting any parameters. TwoQueue implementation is based on https://github.com/hashicorp/golang-lru/blob/master/2q.go

func (*TwoQueue) Elems

func (c *TwoQueue) Elems() []*Item

Elems return all items in cache.

func (*TwoQueue) Get

func (c *TwoQueue) Get(key uint64) (interface{}, bool)

Get retrives an item from cache.

func (*TwoQueue) Len

func (c *TwoQueue) Len() int

Len returns current cache size.

func (*TwoQueue) Peek

func (c *TwoQueue) Peek(key uint64) (interface{}, bool)

Peek reads an item from cache. The action is no considered 'Use'.

func (*TwoQueue) Put

func (c *TwoQueue) Put(key uint64, value interface{})

Put puts an item into cache.

func (*TwoQueue) Remove

func (c *TwoQueue) Remove(key uint64)

Remove eliminates an item from cache.

type Type

type Type int

Type is cache's type such as LRUCache and etc.

const (
	// LRUCache is for LRU cache
	LRUCache Type = 1
	// TwoQueueCache is for 2Q cache
	TwoQueueCache Type = 2
)