From a696f494ea4c262355ec742c5a5c1182b859e0d0 Mon Sep 17 00:00:00 2001 From: Yusuke Kato Date: Wed, 14 Nov 2018 16:34:10 +0900 Subject: [PATCH] Shards (#2) Add concurrent map shards --- .gitignore | 5 + Gopkg.lock | 36 --- Gopkg.toml | 46 ---- Makefile | 4 +- README.md | 112 ++++++++- circle.yml | 3 +- example/main.go | 6 +- gache.go | 252 +++++++++++++------ gache_bench_test.go | 386 ++++++++++++++++++++++++++--- gache_test.go | 580 +++++++++++++++++++++++++++++++++++++------- go.mod | 13 + go.sum | 22 ++ images/bench.png | Bin 153434 -> 0 bytes 13 files changed, 1173 insertions(+), 292 deletions(-) delete mode 100644 Gopkg.lock delete mode 100644 Gopkg.toml create mode 100644 go.mod create mode 100644 go.sum delete mode 100644 images/bench.png diff --git a/.gitignore b/.gitignore index a1338d6..7fdb081 100644 --- a/.gitignore +++ b/.gitignore @@ -7,8 +7,13 @@ # Test binary, build with `go test -c` *.test +*.lock # Output of the go coverage tool, specifically when used with LiteIDE *.out # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 .glide/ + +.lock + +vendor diff --git a/Gopkg.lock b/Gopkg.lock deleted file mode 100644 index b6fc84b..0000000 --- a/Gopkg.lock +++ /dev/null @@ -1,36 +0,0 @@ -# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. - - -[[projects]] - name = "github.com/allegro/bigcache" - packages = [ - ".", - "queue" - ] - revision = "f31987a23e44c5121ef8c8b2f2ea2e8ffa37b068" - version = "v1.1.0" - -[[projects]] - branch = "master" - name = "github.com/bluele/gcache" - packages = ["."] - revision = "472614239ac7e5bc6461e237c798a6ebd5aff8c1" - -[[projects]] - name = "github.com/kpango/glg" - packages = ["."] - revision = "cb0c8857f1215695015b871c1a877874f81878b0" - version = "v1.2.1" - -[[projects]] - name = "github.com/patrickmn/go-cache" - packages = ["."] - revision = "a3647f8e31d79543b2d0f0ae2fe5c379d72cedc0" - version = "v2.1.0" - -[solve-meta] - analyzer-name = "dep" - analyzer-version = 1 - inputs-digest = "3de15909f5528ba26b373a5914d2ba26ff4d98b2160dd33467d77dd5839e0b8e" - solver-name = "gps-cdcl" - solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml deleted file mode 100644 index 46493fd..0000000 --- a/Gopkg.toml +++ /dev/null @@ -1,46 +0,0 @@ -# Gopkg.toml example -# -# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html -# for detailed Gopkg.toml documentation. -# -# required = ["github.com/user/thing/cmd/thing"] -# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] -# -# [[constraint]] -# name = "github.com/user/project" -# version = "1.0.0" -# -# [[constraint]] -# name = "github.com/user/project2" -# branch = "dev" -# source = "github.com/myfork/project2" -# -# [[override]] -# name = "github.com/x/y" -# version = "2.4.0" -# -# [prune] -# non-go = false -# go-tests = true -# unused-packages = true - - -[[constraint]] - name = "github.com/allegro/bigcache" - version = "1.1.0" - -[[constraint]] - branch = "master" - name = "github.com/bluele/gcache" - -[[constraint]] - name = "github.com/kpango/glg" - version = "1.2.1" - -[[constraint]] - name = "github.com/patrickmn/go-cache" - version = "2.1.0" - -[prune] - go-tests = true - unused-packages = true diff --git a/Makefile b/Makefile index f180958..0f7c4ca 100644 --- a/Makefile +++ b/Makefile @@ -44,5 +44,5 @@ contributors: git log --format='%aN <%aE>' | sort -fu > CONTRIBUTORS update: - glide upgrade - glide update + rm -rf Gopkg.* vendor + dep init diff --git a/README.md b/README.md index 362709c..948411c 100644 --- a/README.md +++ b/README.md @@ -38,9 +38,117 @@ go get github.com/kpango/gache ``` ## Benchmarks -[gache](https://github.com/kpango/gache) vs [normal map with lock](https://github.com/kpango/gache/blob/master/gache_bench_test.go#L13-L35) vs [bigcache](https://github.com/allegro/bigcache) vs [go-cache](https://github.com/patrickmn/go-cache) vs [gcache](https://github.com/bluele/gcache) +[gache](https://github.com/kpango/gache) vs [gocache](https://github.com/hlts2/gocache) vs [normal map with lock](https://github.com/kpango/gache/blob/master/gache_bench_test.go#L13-L35) vs [go-cache](https://github.com/patrickmn/go-cache) vs [gcache](https://github.com/bluele/gcache) vs [freecache](https://github.com/coocood/freecache) vs [bigcache](https://github.com/allegro/bigcache) vs [go-mcache](https://github.com/OrlovEvgeny/go-mcache) -![Bench](https://github.com/kpango/gache/raw/master/images/bench.png) + +``` +go test -count=5 -run=NONE -bench . -benchmem +goos: darwin +goarch: amd64 +pkg: github.com/kpango/gache +BenchmarkGacheWithSmallDataset-8 3000000 402 ns/op 363 B/op 21 allocs/op +BenchmarkGacheWithSmallDataset-8 3000000 419 ns/op 364 B/op 21 allocs/op +BenchmarkGacheWithSmallDataset-8 3000000 398 ns/op 360 B/op 21 allocs/op +BenchmarkGacheWithSmallDataset-8 5000000 408 ns/op 363 B/op 21 allocs/op +BenchmarkGacheWithSmallDataset-8 5000000 404 ns/op 362 B/op 21 allocs/op +BenchmarkGacheWithBigDataset-8 300 3952278 ns/op 1263755 B/op 64491 allocs/op +BenchmarkGacheWithBigDataset-8 300 4413116 ns/op 1290176 B/op 65317 allocs/op +BenchmarkGacheWithBigDataset-8 300 3918556 ns/op 1270564 B/op 64704 allocs/op +BenchmarkGacheWithBigDataset-8 500 3977327 ns/op 1260602 B/op 64393 allocs/op +BenchmarkGacheWithBigDataset-8 300 3977146 ns/op 1270649 B/op 64707 allocs/op +BenchmarkGocacheWithSmallDataset-8 3000000 481 ns/op 375 B/op 17 allocs/op +BenchmarkGocacheWithSmallDataset-8 3000000 518 ns/op 374 B/op 17 allocs/op +BenchmarkGocacheWithSmallDataset-8 3000000 492 ns/op 374 B/op 17 allocs/op +BenchmarkGocacheWithSmallDataset-8 3000000 505 ns/op 374 B/op 17 allocs/op +BenchmarkGocacheWithSmallDataset-8 3000000 528 ns/op 378 B/op 17 allocs/op +BenchmarkGocacheWithBigDataset-8 300 4228641 ns/op 1299230 B/op 55465 allocs/op +BenchmarkGocacheWithBigDataset-8 300 4267744 ns/op 1320021 B/op 56057 allocs/op +BenchmarkGocacheWithBigDataset-8 300 4496506 ns/op 1303386 B/op 55535 allocs/op +BenchmarkGocacheWithBigDataset-8 300 4227252 ns/op 1281210 B/op 54840 allocs/op +BenchmarkGocacheWithBigDataset-8 300 4428165 ns/op 1336318 B/op 56472 allocs/op +BenchmarkMapWithSmallDataset-8 1000000 1495 ns/op 426 B/op 17 allocs/op +BenchmarkMapWithSmallDataset-8 1000000 1491 ns/op 429 B/op 17 allocs/op +BenchmarkMapWithSmallDataset-8 1000000 1475 ns/op 428 B/op 17 allocs/op +BenchmarkMapWithSmallDataset-8 1000000 1462 ns/op 426 B/op 17 allocs/op +BenchmarkMapWithSmallDataset-8 1000000 1463 ns/op 434 B/op 17 allocs/op +BenchmarkMapWithBigDataset-8 100 10694528 ns/op 2637553 B/op 92025 allocs/op +BenchmarkMapWithBigDataset-8 100 10981050 ns/op 2673483 B/op 93149 allocs/op +BenchmarkMapWithBigDataset-8 100 10711187 ns/op 2588318 B/op 90489 allocs/op +BenchmarkMapWithBigDataset-8 100 10719385 ns/op 2595016 B/op 90696 allocs/op +BenchmarkMapWithBigDataset-8 100 11112614 ns/op 2607860 B/op 91097 allocs/op +BenchmarkGoCacheWithSmallDataset-8 1000000 1598 ns/op 395 B/op 14 allocs/op +BenchmarkGoCacheWithSmallDataset-8 1000000 1617 ns/op 377 B/op 13 allocs/op +BenchmarkGoCacheWithSmallDataset-8 1000000 1617 ns/op 387 B/op 14 allocs/op +BenchmarkGoCacheWithSmallDataset-8 1000000 1645 ns/op 399 B/op 14 allocs/op +BenchmarkGoCacheWithSmallDataset-8 1000000 1639 ns/op 399 B/op 14 allocs/op +BenchmarkGoCacheWithBigDataset-8 100 11059278 ns/op 2486459 B/op 82213 allocs/op +BenchmarkGoCacheWithBigDataset-8 100 10818612 ns/op 2477070 B/op 81918 allocs/op +BenchmarkGoCacheWithBigDataset-8 100 10735781 ns/op 2487358 B/op 82239 allocs/op +BenchmarkGoCacheWithBigDataset-8 100 11110248 ns/op 2506247 B/op 82830 allocs/op +BenchmarkGoCacheWithBigDataset-8 100 10750619 ns/op 2466763 B/op 81597 allocs/op +BenchmarkGCacheLRUWithSmallDataset-8 500000 2799 ns/op 881 B/op 33 allocs/op +BenchmarkGCacheLRUWithSmallDataset-8 500000 2863 ns/op 886 B/op 33 allocs/op +BenchmarkGCacheLRUWithSmallDataset-8 500000 2801 ns/op 858 B/op 32 allocs/op +BenchmarkGCacheLRUWithSmallDataset-8 500000 2838 ns/op 878 B/op 33 allocs/op +BenchmarkGCacheLRUWithSmallDataset-8 500000 2899 ns/op 889 B/op 33 allocs/op +BenchmarkGCacheLRUWithBigDataset-8 100 21905878 ns/op 6583437 B/op 204039 allocs/op +BenchmarkGCacheLRUWithBigDataset-8 100 21967617 ns/op 6642746 B/op 205939 allocs/op +BenchmarkGCacheLRUWithBigDataset-8 100 21583854 ns/op 6588870 B/op 204312 allocs/op +BenchmarkGCacheLRUWithBigDataset-8 100 21609599 ns/op 6633715 B/op 205637 allocs/op +BenchmarkGCacheLRUWithBigDataset-8 100 21720268 ns/op 6582530 B/op 204108 allocs/op +BenchmarkGCacheLFUWithSmallDataset-8 500000 3664 ns/op 1145 B/op 39 allocs/op +BenchmarkGCacheLFUWithSmallDataset-8 500000 3476 ns/op 1168 B/op 40 allocs/op +BenchmarkGCacheLFUWithSmallDataset-8 500000 3487 ns/op 1150 B/op 39 allocs/op +BenchmarkGCacheLFUWithSmallDataset-8 500000 3544 ns/op 1154 B/op 40 allocs/op +BenchmarkGCacheLFUWithSmallDataset-8 500000 3412 ns/op 1166 B/op 40 allocs/op +BenchmarkGCacheLFUWithBigDataset-8 100 22923400 ns/op 6305977 B/op 202064 allocs/op +BenchmarkGCacheLFUWithBigDataset-8 100 22732759 ns/op 6299839 B/op 201837 allocs/op +BenchmarkGCacheLFUWithBigDataset-8 100 23036891 ns/op 6221560 B/op 199385 allocs/op +BenchmarkGCacheLFUWithBigDataset-8 100 22350515 ns/op 6179889 B/op 198121 allocs/op +BenchmarkGCacheLFUWithBigDataset-8 100 23027119 ns/op 6262824 B/op 200629 allocs/op +BenchmarkGCacheARCWithSmallDataset-8 500000 3353 ns/op 1029 B/op 38 allocs/op +BenchmarkGCacheARCWithSmallDataset-8 500000 3396 ns/op 1015 B/op 37 allocs/op +BenchmarkGCacheARCWithSmallDataset-8 500000 3384 ns/op 1013 B/op 37 allocs/op +BenchmarkGCacheARCWithSmallDataset-8 500000 3454 ns/op 1016 B/op 37 allocs/op +BenchmarkGCacheARCWithSmallDataset-8 500000 3349 ns/op 1028 B/op 38 allocs/op +BenchmarkGCacheARCWithBigDataset-8 30 66863366 ns/op 17088409 B/op 520780 allocs/op +BenchmarkGCacheARCWithBigDataset-8 30 65763199 ns/op 17214454 B/op 524796 allocs/op +BenchmarkGCacheARCWithBigDataset-8 30 67129051 ns/op 17168499 B/op 523464 allocs/op +BenchmarkGCacheARCWithBigDataset-8 30 66670352 ns/op 17055736 B/op 519778 allocs/op +BenchmarkGCacheARCWithBigDataset-8 30 66434197 ns/op 17216688 B/op 524492 allocs/op +BenchmarkFreeCacheWithSmallDataset-8 1000000 1252 ns/op 233 B/op 10 allocs/op +BenchmarkFreeCacheWithSmallDataset-8 1000000 1162 ns/op 244 B/op 10 allocs/op +BenchmarkFreeCacheWithSmallDataset-8 1000000 1315 ns/op 251 B/op 11 allocs/op +BenchmarkFreeCacheWithSmallDataset-8 1000000 1187 ns/op 240 B/op 10 allocs/op +BenchmarkFreeCacheWithSmallDataset-8 1000000 1323 ns/op 253 B/op 11 allocs/op +BenchmarkFreeCacheWithBigDataset-8 100 21859272 ns/op 128838031 B/op 103292 allocs/op +BenchmarkFreeCacheWithBigDataset-8 100 22699363 ns/op 128848017 B/op 103603 allocs/op +BenchmarkFreeCacheWithBigDataset-8 100 21826765 ns/op 128784471 B/op 101618 allocs/op +BenchmarkFreeCacheWithBigDataset-8 100 21667325 ns/op 128808870 B/op 102381 allocs/op +BenchmarkFreeCacheWithBigDataset-8 100 22453480 ns/op 128834411 B/op 103178 allocs/op +BenchmarkBigCacheWithSmallDataset-8 1000000 1538 ns/op 696 B/op 16 allocs/op +BenchmarkBigCacheWithSmallDataset-8 1000000 1506 ns/op 702 B/op 16 allocs/op +BenchmarkBigCacheWithSmallDataset-8 1000000 1510 ns/op 708 B/op 17 allocs/op +BenchmarkBigCacheWithSmallDataset-8 1000000 1520 ns/op 688 B/op 16 allocs/op +BenchmarkBigCacheWithSmallDataset-8 1000000 1442 ns/op 694 B/op 16 allocs/op +BenchmarkBigCacheWithBigDataset-8 20 54704611 ns/op 227761291 B/op 270608 allocs/op +BenchmarkBigCacheWithBigDataset-8 30 48909419 ns/op 233258953 B/op 222040 allocs/op +BenchmarkBigCacheWithBigDataset-8 30 47253632 ns/op 233259122 B/op 221626 allocs/op +BenchmarkBigCacheWithBigDataset-8 30 46212659 ns/op 232961277 B/op 212274 allocs/op +BenchmarkBigCacheWithBigDataset-8 30 48044707 ns/op 233072465 B/op 216352 allocs/op +BenchmarkMCacheWithSmallDataset-8 100000 15528 ns/op 6983 B/op 121 allocs/op +BenchmarkMCacheWithSmallDataset-8 100000 16636 ns/op 7085 B/op 126 allocs/op +BenchmarkMCacheWithSmallDataset-8 100000 14784 ns/op 6992 B/op 123 allocs/op +BenchmarkMCacheWithSmallDataset-8 100000 17371 ns/op 7509 B/op 137 allocs/op +BenchmarkMCacheWithSmallDataset-8 100000 20663 ns/op 7204 B/op 133 allocs/op +BenchmarkMCacheWithBigDataset-8 20 71301439 ns/op 19404819 B/op 347395 allocs/op +BenchmarkMCacheWithBigDataset-8 30 58963700 ns/op 19795017 B/op 390273 allocs/op +BenchmarkMCacheWithBigDataset-8 50 41901923 ns/op 11794883 B/op 298868 allocs/op +BenchmarkMCacheWithBigDataset-8 50 41806838 ns/op 13804077 B/op 332976 allocs/op +BenchmarkMCacheWithBigDataset-8 50 41032910 ns/op 14261304 B/op 343917 allocs/op +PASS +ok github.com/kpango/gache 210.683s +``` ## Contribution 1. Fork it ( https://github.com/kpango/gache/fork ) diff --git a/circle.yml b/circle.yml index ae6e3e1..a445bbe 100644 --- a/circle.yml +++ b/circle.yml @@ -18,11 +18,10 @@ dependencies: - pwd - echo "${PROJECT_PATH}" - go get -u -v github.com/golang/dep/cmd/dep - - dep ensure override: - mkdir -p ~/.go_project/src/github.com/${CIRCLE_PROJECT_USERNAME} - ln -s ${HOME}/${CIRCLE_PROJECT_REPONAME} ${BUILD_PATH} - - cd $BUILD_PATH && go build -ldflags="-s -w" -v + - cd $BUILD_PATH && dep ensure && go build -ldflags="-s -w" -v test: override: - cd $BUILD_PATH && ./coverage.sh diff --git a/example/main.go b/example/main.go index 491592e..82ef38e 100644 --- a/example/main.go +++ b/example/main.go @@ -9,9 +9,9 @@ import ( func main() { var ( - key1 = "key" - key2 = 5050 - key3 = struct{}{} + key1 = "key1" + key2 = "key2" + key3 = "key3" value1 = "value" value2 = 88888 value3 = struct{}{} diff --git a/gache.go b/gache.go index cf1f301..fc711b3 100644 --- a/gache.go +++ b/gache.go @@ -5,27 +5,43 @@ import ( "sync" "sync/atomic" "time" + + "github.com/cespare/xxhash" + "github.com/kpango/fastime" + "golang.org/x/sync/singleflight" ) type ( // Gache is base interface type Gache interface { Clear() - Delete(interface{}) - DeleteExpired(ctx context.Context) <-chan int - Foreach(func(interface{}, interface{}, int64) bool) Gache - Get(interface{}) (interface{}, bool) - Set(interface{}, interface{}) + Delete(string) + DeleteExpired(ctx context.Context) <-chan uint64 + Foreach(context.Context, func(string, interface{}, int64) bool) Gache + Get(string) (interface{}, bool) + Set(string, interface{}) SetDefaultExpire(time.Duration) Gache - SetWithExpire(interface{}, interface{}, time.Duration) + SetExpiredHook(f func(context.Context, string)) Gache + EnableExpiredHook() Gache + DisableExpiredHook() Gache + SetWithExpire(string, interface{}, time.Duration) StartExpired(context.Context, time.Duration) Gache - ToMap() map[interface{}]interface{} + ToMap(context.Context) *sync.Map } // gache is base instance type gache struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + + shard struct { + data *sync.Map } value struct { @@ -51,8 +67,12 @@ func New() Gache { // newGache returns *gache instance func newGache() *gache { g := &gache{ - data: new(sync.Map), - expire: new(atomic.Value), + expire: new(atomic.Value), + expChan: make(chan string, 1000), + } + g.l = uint64(len(g.shards)) + for i := range g.shards { + g.shards[i] = &shard{data: new(sync.Map)} } g.expire.Store(time.Second * 30) return g @@ -68,7 +88,7 @@ func GetGache() Gache { // isValid checks expiration of value func (v *value) isValid() bool { - return v.expire == 0 || time.Now().UnixNano() < v.expire + return v.expire == 0 || fastime.Now().UnixNano() < v.expire } // SetDefaultExpire set expire duration @@ -78,8 +98,41 @@ func (g *gache) SetDefaultExpire(ex time.Duration) Gache { } // SetDefaultExpire set expire duration -func SetDefaultExpire(ex time.Duration) { - instance.SetDefaultExpire(ex) +func SetDefaultExpire(ex time.Duration) Gache { + return instance.SetDefaultExpire(ex) +} + +// EnableExpiredHook enables expired hook function +func (g *gache) EnableExpiredHook() Gache { + g.expFuncEnabled = true + return g +} + +// EnableExpiredHook enables expired hook function +func EnableExpiredHook() Gache { + return instance.EnableExpiredHook() +} + +// DisableExpiredHook disables expired hook function +func (g *gache) DisableExpiredHook() Gache { + g.expFuncEnabled = false + return g +} + +// DisableExpiredHook disables expired hook function +func DisableExpiredHook() Gache { + return instance.DisableExpiredHook() +} + +// SetExpiredHook set expire hooked function +func (g *gache) SetExpiredHook(f func(context.Context, string)) Gache { + g.expFunc = f + return g +} + +// SetExpiredHook set expire hooked function +func SetExpiredHook(f func(context.Context, string)) Gache { + return instance.SetExpiredHook(f) } // StartExpired starts delete expired value daemon @@ -93,6 +146,8 @@ func (g *gache) StartExpired(ctx context.Context, dur time.Duration) Gache { return case <-tick.C: g.DeleteExpired(ctx) + case key := <-g.expChan: + go g.expFunc(ctx, key) } } }() @@ -100,32 +155,25 @@ func (g *gache) StartExpired(ctx context.Context, dur time.Duration) Gache { } // ToMap returns All Cache Key-Value map -func (g *gache) ToMap() map[interface{}]interface{} { - m := make(map[interface{}]interface{}) - g.data.Range(func(k, v interface{}) bool { - d, ok := v.(*value) - if ok { - if d.isValid() { - m[k] = *d.val - } else { - g.Delete(k) - } - return true - } - return false +func (g *gache) ToMap(ctx context.Context) *sync.Map { + m := new(sync.Map) + g.Foreach(ctx, func(key string, val interface{}, exp int64) bool { + m.Store(key, val) + return true }) + return m } // ToMap returns All Cache Key-Value map -func ToMap() map[interface{}]interface{} { - return instance.ToMap() +func ToMap(ctx context.Context) *sync.Map { + return instance.ToMap(ctx) } // get returns value & exists from key -func (g *gache) get(key interface{}) (interface{}, bool) { - - v, ok := g.data.Load(key) +func (g *gache) get(key string) (interface{}, bool) { + shard := g.getShard(key) + v, ok := shard.Load(key) if !ok { return nil, false @@ -134,7 +182,7 @@ func (g *gache) get(key interface{}) (interface{}, bool) { d, ok := v.(*value) if !ok || !d.isValid() { - g.data.Delete(key) + g.expiration(key) return nil, false } @@ -142,112 +190,156 @@ func (g *gache) get(key interface{}) (interface{}, bool) { } // Get returns value & exists from key -func (g *gache) Get(key interface{}) (interface{}, bool) { +func (g *gache) Get(key string) (interface{}, bool) { return g.get(key) } // Get returns value & exists from key -func Get(key interface{}) (interface{}, bool) { +func Get(key string) (interface{}, bool) { return instance.get(key) } // set sets key-value & expiration to Gache -func (g *gache) set(key, val interface{}, expire time.Duration) { +func (g *gache) set(key string, val interface{}, expire time.Duration) { var exp int64 if expire > 0 { - exp = time.Now().Add(expire).UnixNano() + exp = fastime.Now().Add(expire).UnixNano() } - g.data.Store(key, &value{ + g.getShard(key).Store(key, &value{ expire: exp, val: &val, }) } // SetWithExpire sets key-value & expiration to Gache -func (g *gache) SetWithExpire(key, val interface{}, expire time.Duration) { +func (g *gache) SetWithExpire(key string, val interface{}, expire time.Duration) { g.set(key, val, expire) } // SetWithExpire sets key-value & expiration to Gache -func SetWithExpire(key, val interface{}, expire time.Duration) { +func SetWithExpire(key string, val interface{}, expire time.Duration) { instance.set(key, val, expire) } // Set sets key-value to Gache using default expiration -func (g *gache) Set(key, val interface{}) { +func (g *gache) Set(key string, val interface{}) { g.set(key, val, g.expire.Load().(time.Duration)) } // Set sets key-value to Gache using default expiration -func Set(key, val interface{}) { +func Set(key string, val interface{}) { instance.set(key, val, instance.expire.Load().(time.Duration)) } // Delete deletes value from Gache using key -func (g *gache) Delete(key interface{}) { - g.data.Delete(key) +func (g *gache) Delete(key string) { + g.getShard(key).Delete(key) } // Delete deletes value from Gache using key -func Delete(key interface{}) { +func Delete(key string) { instance.Delete(key) } +func (g *gache) expiration(key string) { + g.expGroup.Do(key, func() (interface{}, error) { + g.Delete(key) + if g.expFuncEnabled { + g.expChan <- key + } + return nil, nil + }) +} + // DeleteExpired deletes expired value from Gache it can be cancel using context -func (g *gache) DeleteExpired(ctx context.Context) <-chan int { - c := make(chan int) +func (g *gache) DeleteExpired(ctx context.Context) <-chan uint64 { + ch := make(chan uint64) go func() { - var rows int - g.data.Range(func(k, v interface{}) bool { + wg := new(sync.WaitGroup) + rows := new(uint64) + for i := range g.shards { + g.shards[i].data.Range(func(k, v interface{}) bool { + result := make(chan bool) + wg.Add(1) + go func(c context.Context) { + select { + case <-c.Done(): + wg.Done() + result <- false + return + default: + d, ok := v.(*value) + if ok { + if !d.isValid() { + g.expiration(k.(string)) + atomic.AddUint64(rows, 1) + } + result <- true + wg.Done() + return + } + result <- false + wg.Done() + return + } + }(ctx) + return <-result + }) + } + wg.Wait() + ch <- atomic.LoadUint64(rows) + }() + return ch +} + +// DeleteExpired deletes expired value from Gache it can be cancel using context +func DeleteExpired(ctx context.Context) <-chan uint64 { + return instance.DeleteExpired(ctx) +} + +// Foreach calls f sequentially for each key and value present in the Gache. +func (g *gache) Foreach(ctx context.Context, f func(string, interface{}, int64) bool) Gache { + wg := new(sync.WaitGroup) + for _, shard := range g.shards { + shard.data.Range(func(k, v interface{}) bool { select { case <-ctx.Done(): return false default: d, ok := v.(*value) - if ok && !d.isValid() { - g.data.Delete(k) - rows++ + if ok { + if d.isValid() { + return f(k.(string), *d.val, d.expire) + } + g.expiration(k.(string)) + return true } - return true + return false } }) - c <- rows - }() - return c + } + wg.Wait() + return g } -// DeleteExpired deletes expired value from Gache it can be cancel using context -func DeleteExpired(ctx context.Context) <-chan int { - return instance.DeleteExpired(ctx) +// Foreach calls f sequentially for each key and value present in the Gache. +func Foreach(ctx context.Context, f func(string, interface{}, int64) bool) Gache { + return instance.Foreach(ctx, f) } -// Foreach calls f sequentially for each key and value present in the Gache. -func (g *gache) Foreach(f func(interface{}, interface{}, int64) bool) Gache { - g.data.Range(func(k, v interface{}) bool { - d, ok := v.(*value) - if ok { - if d.isValid() { - return f(k, *d.val, d.expire) - } - g.Delete(k) - } - return false - }) - return g +func (g *gache) selectShard(key string) uint64 { + return xxhash.Sum64String(key) } -// Foreach calls f sequentially for each key and value present in the Gache. -func Foreach(f func(interface{}, interface{}, int64) bool) Gache { - return instance.Foreach(f) +func (g *gache) getShard(key string) *sync.Map { + return g.shards[g.selectShard(key)%g.l].data } // Clear deletes all key and value present in the Gache. func (g *gache) Clear() { - g.data.Range(func(key, _ interface{}) bool { - g.data.Delete(key) - return true - }) - g.data = new(sync.Map) + for i := range g.shards { + g.shards[i] = &shard{data: new(sync.Map)} + } } // Clear deletes all key and value present in the Gache. diff --git a/gache_bench_test.go b/gache_bench_test.go index 26cfa59..58155f5 100644 --- a/gache_bench_test.go +++ b/gache_bench_test.go @@ -1,12 +1,16 @@ package gache import ( + "math/rand" "sync" "testing" "time" + mcache "github.com/OrlovEvgeny/go-mcache" "github.com/allegro/bigcache" "github.com/bluele/gcache" + "github.com/coocood/freecache" + "github.com/hlts2/gocache" cache "github.com/patrickmn/go-cache" ) @@ -35,27 +39,57 @@ func (m *DefaultMap) Set(key, val interface{}) { } var ( - data = map[string]string{ + bigData = map[string]string{} + bigDataLen = 10000 + + smallData = map[string]string{ "string": "aaaa", "int": "123", "float": "99.99", "struct": "struct{}{}", } - // data = map[string]interface{}{ - // "string": "aaaa", - // "int": 123, - // "float": 99.99, - // "struct": struct{}{}, - // } ) -func BenchmarkGache(b *testing.B) { +func init() { + for i := 0; i < bigDataLen; i++ { + bigData[randStr(i)] = randStr(1000) + } +} + +var randSrc = rand.NewSource(time.Now().UnixNano()) + +const ( + rs6Letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + rs6LetterIdxBits = 6 + rs6LetterIdxMask = 1<= 0; { + if remain == 0 { + cache, remain = randSrc.Int63(), rs6LetterIdxMax + } + idx := int(cache & rs6LetterIdxMask) + if idx < len(rs6Letters) { + b[i] = rs6Letters[idx] + i-- + } + cache >>= rs6LetterIdxBits + remain-- + } + return string(b) +} + +func BenchmarkGacheWithSmallDataset(b *testing.B) { New() b.ResetTimer() b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { Set(k, v) val, ok := Get(k) if !ok { @@ -69,18 +103,78 @@ func BenchmarkGache(b *testing.B) { }) } -func BenchmarkMap(b *testing.B) { +func BenchmarkGacheWithBigDataset(b *testing.B) { + New() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + Set(k, v) + val, ok := Get(k) + if !ok { + b.Errorf("Gache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGocacheWithSmallDataset(b *testing.B) { + gc := gocache.New() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range smallData { + gc.Set(k, v) + val, ok := gc.Get(k) + if !ok { + b.Errorf("GoCache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGocacheWithBigDataset(b *testing.B) { + gc := gocache.New() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + gc.Set(k, v) + val, ok := gc.Get(k) + if !ok { + b.Errorf("GoCache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkMapWithSmallDataset(b *testing.B) { m := NewDefault() b.ResetTimer() b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { m.Set(k, v) val, ok := m.Get(k) if !ok { - b.Errorf("Gache Get failed key: %v\tval: %v\n", k, v) + b.Errorf("Map Get failed key: %v\tval: %v\n", k, v) } if val != v { b.Errorf("expect %v but got %v", v, val) @@ -90,35 +184,34 @@ func BenchmarkMap(b *testing.B) { }) } -func BenchmarkBigCache(b *testing.B) { - cfg := bigcache.DefaultConfig(10 * time.Minute) - cfg.Verbose = false - c, _ := bigcache.NewBigCache(cfg) +func BenchmarkMapWithBigDataset(b *testing.B) { + m := NewDefault() b.ResetTimer() b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { - c.Set(k, []byte(v)) - val, err := c.Get(k) - if err != nil { - b.Errorf("BigCahce Get failed key: %v\tval: %v\n", k, v) + for k, v := range bigData { + m.Set(k, v) + + val, ok := m.Get(k) + if !ok { + b.Errorf("Map Get failed key: %v\tval: %v\n", k, v) } - if string(val) != v { - b.Errorf("expect %v but got %v", v, string(val)) + if val != v { + b.Errorf("expect %v but got %v", v, val) } } } }) } -func BenchmarkGoCache(b *testing.B) { +func BenchmarkGoCacheWithSmallDataset(b *testing.B) { c := cache.New(5*time.Minute, 10*time.Minute) b.ResetTimer() b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { c.Set(k, v, cache.DefaultExpiration) val, ok := c.Get(k) if !ok { @@ -132,7 +225,27 @@ func BenchmarkGoCache(b *testing.B) { }) } -func BenchmarkGCacheLRU(b *testing.B) { +func BenchmarkGoCacheWithBigDataset(b *testing.B) { + c := cache.New(5*time.Minute, 10*time.Minute) + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + c.Set(k, v, cache.DefaultExpiration) + val, ok := c.Get(k) + if !ok { + b.Errorf("Go-Cache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGCacheLRUWithSmallDataset(b *testing.B) { gc := gcache.New(20). LRU(). Build() @@ -140,20 +253,45 @@ func BenchmarkGCacheLRU(b *testing.B) { b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { gc.SetWithExpire(k, v, time.Second*30) val, err := gc.Get(k) if err != nil { - b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) } if val != v { - b.Errorf("expect %v but got %v", v, val) + // b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGCacheLRUWithBigDataset(b *testing.B) { + gc := gcache.New(20). + LRU(). + Build() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + gc.SetWithExpire(k, v, time.Second*30) + val, err := gc.Get(k) + if err != nil { + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + // b.Errorf("expect %v but got %v", v, val) } } } }) } -func BenchmarkGCacheLFU(b *testing.B) { + +func BenchmarkGCacheLFUWithSmallDataset(b *testing.B) { gc := gcache.New(20). LFU(). Build() @@ -161,21 +299,45 @@ func BenchmarkGCacheLFU(b *testing.B) { b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { gc.SetWithExpire(k, v, time.Second*30) val, err := gc.Get(k) if err != nil { - b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) } if val != v { - b.Errorf("expect %v but got %v", v, val) + // b.Errorf("expect %v but got %v", v, val) } } } }) } -func BenchmarkGCacheARC(b *testing.B) { +func BenchmarkGCacheLFUWithBigDataset(b *testing.B) { + gc := gcache.New(20). + LFU(). + Build() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + gc.SetWithExpire(k, v, time.Second*30) + val, err := gc.Get(k) + if err != nil { + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + // b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGCacheARCWithSmallDataset(b *testing.B) { gc := gcache.New(20). ARC(). Build() @@ -183,16 +345,168 @@ func BenchmarkGCacheARC(b *testing.B) { b.ReportAllocs() b.RunParallel(func(pb *testing.PB) { for pb.Next() { - for k, v := range data { + for k, v := range smallData { gc.SetWithExpire(k, v, time.Second*30) val, err := gc.Get(k) if err != nil { - b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) } if val != v { + // b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkGCacheARCWithBigDataset(b *testing.B) { + gc := gcache.New(20). + ARC(). + Build() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + gc.SetWithExpire(k, v, time.Second*30) + val, err := gc.Get(k) + if err != nil { + // XXX gcache has a problem . it cannot get long keyname + // b.Errorf("GCache Get failed key: %v\tval: %v\n", k, v) + } + if val != v { + // b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkFreeCacheWithSmallDataset(b *testing.B) { + fc := freecache.NewCache(100 * 1024 * 1024) + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range smallData { + fc.Set([]byte(k), []byte(v), 0) + val, err := fc.Get([]byte(k)) + if err != nil { + b.Errorf("FreeCache Get failed key: %v\tval: %v\n", k, v) + b.Error(err) + } + + if string(val) != v { + b.Errorf("expect %v but got %v", v, val) + } + } + } + }) +} + +func BenchmarkFreeCacheWithBigDataset(b *testing.B) { + fc := freecache.NewCache(100 * 1024 * 1024) + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + fc.Set([]byte(k), []byte(v), 0) + val, err := fc.Get([]byte(k)) + if err != nil { + b.Errorf("FreeCache Get failed key: %v\tval: %v\n", k, v) + b.Error(err) + } + + if string(val) != v { b.Errorf("expect %v but got %v", v, val) } } } }) } + +func BenchmarkBigCacheWithSmallDataset(b *testing.B) { + cfg := bigcache.DefaultConfig(10 * time.Minute) + cfg.Verbose = false + c, _ := bigcache.NewBigCache(cfg) + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range smallData { + c.Set(k, []byte(v)) + val, err := c.Get(k) + if err != nil { + b.Errorf("BigCahce Get failed key: %v\tval: %v\n", k, v) + } + if string(val) != v { + b.Errorf("expect %v but got %v", v, string(val)) + } + } + } + }) +} + +func BenchmarkBigCacheWithBigDataset(b *testing.B) { + cfg := bigcache.DefaultConfig(10 * time.Minute) + cfg.Verbose = false + c, _ := bigcache.NewBigCache(cfg) + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + c.Set(k, []byte(v)) + val, err := c.Get(k) + if err != nil { + b.Errorf("BigCahce Get failed key: %v\tval: %v\n", k, v) + } + if string(val) != v { + b.Errorf("expect %v but got %v", v, string(val)) + } + } + } + }) +} + +func BenchmarkMCacheWithSmallDataset(b *testing.B) { + mc := mcache.StartInstance() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range smallData { + mc.SetPointer(k, v, time.Second*30) + val, ok := mc.GetPointer(k) + if !ok { + b.Errorf("mcache Get failed key: %v\tval: %v\n", k, v) + } + if val.(string) != v { + b.Errorf("expect %v but got %v", v, val.(string)) + } + } + } + }) +} + +func BenchmarkMCacheWithBigDataset(b *testing.B) { + mc := mcache.StartInstance() + b.ResetTimer() + b.ReportAllocs() + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + for k, v := range bigData { + mc.SetPointer(k, v, time.Second*30) + val, ok := mc.GetPointer(k) + if !ok { + b.Errorf("mcache Get failed key: %v\tval: %v\n", k, v) + } + if val.(string) != v { + b.Errorf("expect %v but got %v", v, val.(string)) + } + } + } + }) +} diff --git a/gache_test.go b/gache_test.go index 9f7f2b8..5d0b7b4 100644 --- a/gache_test.go +++ b/gache_test.go @@ -7,6 +7,8 @@ import ( "sync/atomic" "testing" "time" + + "golang.org/x/sync/singleflight" ) func TestNew(t *testing.T) { @@ -84,8 +86,13 @@ func Test_value_isValid(t *testing.T) { func Test_gache_SetDefaultExpire(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { ex time.Duration @@ -101,8 +108,13 @@ func Test_gache_SetDefaultExpire(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } if got := g.SetDefaultExpire(tt.args.ex); !reflect.DeepEqual(got, tt.want) { t.Errorf("gache.SetDefaultExpire() = %v, want %v", got, tt.want) @@ -118,20 +130,189 @@ func TestSetDefaultExpire(t *testing.T) { tests := []struct { name string args args + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := SetDefaultExpire(tt.args.ex); !reflect.DeepEqual(got, tt.want) { + t.Errorf("SetDefaultExpire() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_gache_EnableExpiredHook(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + tests := []struct { + name string + fields fields + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + if got := g.EnableExpiredHook(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("gache.EnableExpiredHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestEnableExpiredHook(t *testing.T) { + tests := []struct { + name string + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := EnableExpiredHook(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("EnableExpiredHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_gache_DisableExpiredHook(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + tests := []struct { + name string + fields fields + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + if got := g.DisableExpiredHook(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("gache.DisableExpiredHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDisableExpiredHook(t *testing.T) { + tests := []struct { + name string + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := DisableExpiredHook(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("DisableExpiredHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_gache_SetExpiredHook(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + type args struct { + f func(context.Context, string) + } + tests := []struct { + name string + fields fields + args args + want Gache + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + if got := g.SetExpiredHook(tt.args.f); !reflect.DeepEqual(got, tt.want) { + t.Errorf("gache.SetExpiredHook() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestSetExpiredHook(t *testing.T) { + type args struct { + f func(context.Context, string) + } + tests := []struct { + name string + args args + want Gache }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - SetDefaultExpire(tt.args.ex) + if got := SetExpiredHook(tt.args.f); !reflect.DeepEqual(got, tt.want) { + t.Errorf("SetExpiredHook() = %v, want %v", got, tt.want) + } }) } } func Test_gache_StartExpired(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { ctx context.Context @@ -148,8 +329,13 @@ func Test_gache_StartExpired(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } if got := g.StartExpired(tt.args.ctx, tt.args.dur); !reflect.DeepEqual(got, tt.want) { t.Errorf("gache.StartExpired() = %v, want %v", got, tt.want) @@ -160,23 +346,37 @@ func Test_gache_StartExpired(t *testing.T) { func Test_gache_ToMap(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + type args struct { + ctx context.Context } tests := []struct { name string fields fields - want map[interface{}]interface{} + args args + want *sync.Map }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } - if got := g.ToMap(); !reflect.DeepEqual(got, tt.want) { + if got := g.ToMap(tt.args.ctx); !reflect.DeepEqual(got, tt.want) { t.Errorf("gache.ToMap() = %v, want %v", got, tt.want) } }) @@ -184,15 +384,19 @@ func Test_gache_ToMap(t *testing.T) { } func TestToMap(t *testing.T) { + type args struct { + ctx context.Context + } tests := []struct { name string - want map[interface{}]interface{} + args args + want *sync.Map }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := ToMap(); !reflect.DeepEqual(got, tt.want) { + if got := ToMap(tt.args.ctx); !reflect.DeepEqual(got, tt.want) { t.Errorf("ToMap() = %v, want %v", got, tt.want) } }) @@ -201,11 +405,16 @@ func TestToMap(t *testing.T) { func Test_gache_get(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - key interface{} + key string } tests := []struct { name string @@ -219,8 +428,13 @@ func Test_gache_get(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } got, got1 := g.get(tt.args.key) if !reflect.DeepEqual(got, tt.want) { @@ -235,11 +449,16 @@ func Test_gache_get(t *testing.T) { func Test_gache_Get(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - key interface{} + key string } tests := []struct { name string @@ -253,8 +472,13 @@ func Test_gache_Get(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } got, got1 := g.Get(tt.args.key) if !reflect.DeepEqual(got, tt.want) { @@ -269,7 +493,7 @@ func Test_gache_Get(t *testing.T) { func TestGet(t *testing.T) { type args struct { - key interface{} + key string } tests := []struct { name string @@ -294,11 +518,16 @@ func TestGet(t *testing.T) { func Test_gache_set(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - key interface{} + key string val interface{} expire time.Duration } @@ -312,8 +541,13 @@ func Test_gache_set(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } g.set(tt.args.key, tt.args.val, tt.args.expire) }) @@ -322,11 +556,16 @@ func Test_gache_set(t *testing.T) { func Test_gache_SetWithExpire(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - key interface{} + key string val interface{} expire time.Duration } @@ -340,63 +579,78 @@ func Test_gache_SetWithExpire(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } g.SetWithExpire(tt.args.key, tt.args.val, tt.args.expire) }) } } -func Test_gache_Set(t *testing.T) { - type fields struct { - data *sync.Map - expire *atomic.Value - } +func TestSetWithExpire(t *testing.T) { type args struct { - key interface{} - val interface{} + key string + val interface{} + expire time.Duration } tests := []struct { - name string - fields fields - args args + name string + args args }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, - } - g.Set(tt.args.key, tt.args.val) + SetWithExpire(tt.args.key, tt.args.val, tt.args.expire) }) } } -func TestSetWithExpire(t *testing.T) { +func Test_gache_Set(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } type args struct { - key interface{} - val interface{} - expire time.Duration + key string + val interface{} } tests := []struct { - name string - args args + name string + fields fields + args args }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - SetWithExpire(tt.args.key, tt.args.val, tt.args.expire) + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + g.Set(tt.args.key, tt.args.val) }) } } func TestSet(t *testing.T) { type args struct { - key interface{} + key string val interface{} } tests := []struct { @@ -414,11 +668,16 @@ func TestSet(t *testing.T) { func Test_gache_Delete(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - key interface{} + key string } tests := []struct { name string @@ -430,8 +689,13 @@ func Test_gache_Delete(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } g.Delete(tt.args.key) }) @@ -440,7 +704,7 @@ func Test_gache_Delete(t *testing.T) { func TestDelete(t *testing.T) { type args struct { - key interface{} + key string } tests := []struct { name string @@ -455,10 +719,51 @@ func TestDelete(t *testing.T) { } } +func Test_gache_expiration(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + type args struct { + key string + } + tests := []struct { + name string + fields fields + args args + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + g.expiration(tt.args.key) + }) + } +} + func Test_gache_DeleteExpired(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { ctx context.Context @@ -467,15 +772,20 @@ func Test_gache_DeleteExpired(t *testing.T) { name string fields fields args args - want <-chan int + want <-chan uint64 }{ // TODO: Add test cases. } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } if got := g.DeleteExpired(tt.args.ctx); !reflect.DeepEqual(got, tt.want) { t.Errorf("gache.DeleteExpired() = %v, want %v", got, tt.want) @@ -491,7 +801,7 @@ func TestDeleteExpired(t *testing.T) { tests := []struct { name string args args - want <-chan int + want <-chan uint64 }{ // TODO: Add test cases. } @@ -506,11 +816,17 @@ func TestDeleteExpired(t *testing.T) { func Test_gache_Foreach(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } type args struct { - f func(interface{}, interface{}, int64) bool + ctx context.Context + f func(string, interface{}, int64) bool } tests := []struct { name string @@ -523,10 +839,15 @@ func Test_gache_Foreach(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } - if got := g.Foreach(tt.args.f); !reflect.DeepEqual(got, tt.want) { + if got := g.Foreach(tt.args.ctx, tt.args.f); !reflect.DeepEqual(got, tt.want) { t.Errorf("gache.Foreach() = %v, want %v", got, tt.want) } }) @@ -535,7 +856,8 @@ func Test_gache_Foreach(t *testing.T) { func TestForeach(t *testing.T) { type args struct { - f func(interface{}, interface{}, int64) bool + ctx context.Context + f func(string, interface{}, int64) bool } tests := []struct { name string @@ -546,17 +868,100 @@ func TestForeach(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := Foreach(tt.args.f); !reflect.DeepEqual(got, tt.want) { + if got := Foreach(tt.args.ctx, tt.args.f); !reflect.DeepEqual(got, tt.want) { t.Errorf("Foreach() = %v, want %v", got, tt.want) } }) } } +func Test_gache_selectShard(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + type args struct { + key string + } + tests := []struct { + name string + fields fields + args args + want uint64 + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + if got := g.selectShard(tt.args.key); got != tt.want { + t.Errorf("gache.selectShard() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_gache_getShard(t *testing.T) { + type fields struct { + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group + } + type args struct { + key string + } + tests := []struct { + name string + fields fields + args args + want *sync.Map + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + g := &gache{ + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, + } + if got := g.getShard(tt.args.key); !reflect.DeepEqual(got, tt.want) { + t.Errorf("gache.getShard() = %v, want %v", got, tt.want) + } + }) + } +} + func Test_gache_Clear(t *testing.T) { type fields struct { - data *sync.Map - expire *atomic.Value + l uint64 + shards [255]*shard + expire *atomic.Value + expFuncEnabled bool + expFunc func(context.Context, string) + expChan chan string + expGroup singleflight.Group } tests := []struct { name string @@ -567,8 +972,13 @@ func Test_gache_Clear(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := &gache{ - data: tt.fields.data, - expire: tt.fields.expire, + l: tt.fields.l, + shards: tt.fields.shards, + expire: tt.fields.expire, + expFuncEnabled: tt.fields.expFuncEnabled, + expFunc: tt.fields.expFunc, + expChan: tt.fields.expChan, + expGroup: tt.fields.expGroup, } g.Clear() }) diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..000de34 --- /dev/null +++ b/go.mod @@ -0,0 +1,13 @@ +module github.com/kpango/gache + +require ( + github.com/OrlovEvgeny/go-mcache v0.0.0-20181113222421-bed69649df7d + github.com/allegro/bigcache v1.1.0 + github.com/bluele/gcache v0.0.0-20171010155617-472614239ac7 + github.com/cespare/xxhash v1.1.0 + github.com/coocood/freecache v1.0.1 + github.com/hlts2/gocache v0.0.0-20181007125314-e9a99e525ba1 + github.com/kpango/fastime v1.0.0 + github.com/patrickmn/go-cache v2.1.0+incompatible + golang.org/x/sync v0.0.0-20181108010431-42b317875d0f +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..4c87708 --- /dev/null +++ b/go.sum @@ -0,0 +1,22 @@ +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/OrlovEvgeny/go-mcache v0.0.0-20181113222421-bed69649df7d h1:C+bJcFiEFeXj3iThSj0LDeKY1moobmwQpIZmkjjjUlY= +github.com/OrlovEvgeny/go-mcache v0.0.0-20181113222421-bed69649df7d/go.mod h1:HyURA1Z5rjNkt9E7XyiegZk1ZBvvB+1vYzkeu52goIc= +github.com/allegro/bigcache v1.1.0 h1:MLuIKTjdxDc+qsG2rhjsYjsHQC5LUGjIWzutg7M+W68= +github.com/allegro/bigcache v1.1.0/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= +github.com/bluele/gcache v0.0.0-20171010155617-472614239ac7 h1:NpQ+gkFOH27AyDypSCJ/LdsIi/b4rdnEb1N5+IpFfYs= +github.com/bluele/gcache v0.0.0-20171010155617-472614239ac7/go.mod h1:8c4/i2VlovMO2gBnHGQPN5EJw+H0lx1u/5p+cgsXtCk= +github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/coocood/freecache v1.0.1 h1:oFyo4msX2c0QIKU+kuMJUwsKamJ+AKc2JJrKcMszJ5M= +github.com/coocood/freecache v1.0.1/go.mod h1:ePwxCDzOYvARfHdr1pByNct1at3CoKnsipOHwKlNbzI= +github.com/hlts2/gocache v0.0.0-20181007125314-e9a99e525ba1 h1:HyfoKeRGf+UEyr2emroIKYFTrU5W15VaQ2+jMJMD79w= +github.com/hlts2/gocache v0.0.0-20181007125314-e9a99e525ba1/go.mod h1:u/v6wO8kS57bViN/degQAjOX3zGWVx3VW2HOClP2Vcc= +github.com/kpango/fastime v1.0.0 h1:tZeI+eEyHHYKkTkKOiOZ5MeeRJmliuZlGV7aK7S2rkE= +github.com/kpango/fastime v1.0.0/go.mod h1:Y5XY5bLG5yc7g2XmMUzc22XYV1XaH+KgUOHkDvLp4SA= +github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc= +github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/vmihailenco/msgpack v4.0.1+incompatible h1:RMF1enSPeKTlXrXdOcqjFUElywVZjjC6pqse21bKbEU= +github.com/vmihailenco/msgpack v4.0.1+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= diff --git a/images/bench.png b/images/bench.png deleted file mode 100644 index 1145b9f9d852ae84be3f36c9982724c6af39fa7d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 153434 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

<017 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/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