Mlcache

Multi-Level Cache

mlcache is a multi-level cache interface with multiple read and write patterns supported.

Some of the features available in mlcache -

• Arranging cache implementations in a multi-level cache format.
• Option to choose from cache read and write patterns.
• Read patterns supported are ReadThrough and CacheAside.
• Write patterns supported are WriteThrough, WriteAround and WriteBack.
• Package defined limit on number of cache levels.
• User defined limit on max size of cache value.

Import path

import "github.com/gptankit/mlcache"

Typical usage

mlcache exposes a Cacher interface type that all caches must implement -

type Cacher interface {
	Get(key *CacheKey) (*bytes.Buffer, time.Time, error)
	Put(key *CacheKey, val *bytes.Buffer, expires time.Time) (CacheStatus, error)
	Del(key *CacheKey) (CacheStatus, error)
	IsPresent(key *CacheKey) (CacheStatus, error)
	Flush() error
}

Assuming NewLnCacher() is a user defined function that creates a cache object satisfying Cacher interface and you have decided a read and write pattern combination that work best with your application setup, you can then go on to create the multi-level cacher and start using it -

func NewMultiLevelCache(readPattern ReadPattern, writePattern WritePattern, maxValSize int, caches ...Cacher) (Cacher, error)

l1Cache, l2Cache, l3Cache := NewL1Cacher(), NewL2Cacher(), NewL3Cacher() // and so on...
cacher, mlcErr := mlcache.NewMultiLevelCache(mlcache.ReadThrough, mlcache.WriteThrough, 676, l1Cache, l2Cache, l3Cache)
if mlcErr != nil {
  // log error and panic
}

// create a key and a value
key := mlcache.NewCacheKey("my-key")
val := bytes.NewBuffer([]byte("my-val"))

// add to ml cache with selected write pattern
cacheStatus, putErr := cacher.Put(key, val, time.Now().UTC().Add(24*time.Hour))
if putErr != nil {
  // log error
}
if cacheStatus {
  // do your thing
}

// get from ml cache with selected read pattern
val, _, getErr := cacher.Get(key)
if getErr != nil {
  // log error
}
if val != nil {
  // do your thing
}

Benchmarks (Get/Put)

Below are mlcache benchmarks with frequently used read/write patterns. All test cases include 3 levels of caching (L1,L2,L3) and store cache items in a map data structure with locking in place (R=Read, W=Write) -

| BenchmarkCase | Iterations | TimePerIteration | | ------------- | ---------- | ---------------- | | ReadThrough/WriteThrough || | BenchmarkCacher/R1-16 | 13849582 | 85.54 ns/op | | BenchmarkCacher/W1-16 | 8077688 | 142.2 ns/op | | CacheAside/WriteThrough || | BenchmarkCacher/R2-16 | 2278107 | 529.7 ns/op | | BenchmarkCacher/W2-16 | 8070732 | 149.7 ns/op | | ReadThrough/WriteAround || | BenchmarkCacher/R3-16 | 13211317 | 86.74 ns/op | | BenchmarkCacher/W3-16 | 11639502 | 100.4 ns/op | | CacheAside/WriteAround || | BenchmarkCacher/R4-16 | 2250987 | 528.0 ns/op | | BenchmarkCacher/W4-16 | 12147741 | 95.82 ns/op | | ReadThrough/WriteBack || | BenchmarkCacher/R5-16 | 12350166 | 85.95 ns/op | | BenchmarkCacher/W5-16 | 2071774 | 691.1 ns/op | | CacheAside/WriteBack || | BenchmarkCacher/R6-16 | 2448288 | 496.4 ns/op | | BenchmarkCacher/W6-16 | 2102917 | 640.8 ns/op |

The numbers suggest that ReadThrough/WriteThrough and ReadThrough/WriteAround perform considerably better than other patterns under heavy load. Though, all patterns are useful under different circumstances and must be carefully studied and chosen depending on the needs of the application.

Feel free to play around and post feedbacks