bigcache
v3.1.0
Cache yang cepat, bersamaan, penggusuran dalam memori yang ditulis untuk menjaga sejumlah besar entri tanpa dampak pada kinerja. Bigcache menyimpan entri di tumpukan tetapi menghilangkan GC untuk mereka. Untuk mencapai itu, operasi pada irisan byte terjadi, oleh karena itu serialisasi entri (DE) di depan cache akan diperlukan di sebagian besar kasus penggunaan.
Membutuhkan go 1.12 atau lebih baru.
import (
"fmt"
"context"
"github.com/allegro/bigcache/v3"
)
cache , _ := bigcache . New ( context . Background (), bigcache . DefaultConfig ( 10 * time . Minute ))
cache . Set ( "my-unique-key" , [] byte ( "value" ))
entry , _ := cache . Get ( "my-unique-key" )
fmt . Println ( string ( entry ))Ketika beban cache dapat diprediksi sebelumnya maka lebih baik menggunakan inisialisasi khusus karena alokasi memori tambahan dapat dihindari dengan cara itu.
import (
"log"
"github.com/allegro/bigcache/v3"
)
config := bigcache. Config {
// number of shards (must be a power of 2)
Shards : 1024 ,
// time after which entry can be evicted
LifeWindow : 10 * time . Minute ,
// Interval between removing expired entries (clean up).
// If set to <= 0 then no action is performed.
// Setting to < 1 second is counterproductive — bigcache has a one second resolution.
CleanWindow : 5 * time . Minute ,
// rps * lifeWindow, used only in initial memory allocation
MaxEntriesInWindow : 1000 * 10 * 60 ,
// max entry size in bytes, used only in initial memory allocation
MaxEntrySize : 500 ,
// prints information about additional memory allocation
Verbose : true ,
// cache will not allocate more memory than this limit, value in MB
// if value is reached then the oldest entries can be overridden for the new ones
// 0 value means no size limit
HardMaxCacheSize : 8192 ,
// callback fired when the oldest entry is removed because of its expiration time or no space left
// for the new entry, or because delete was called. A bitmask representing the reason will be returned.
// Default value is nil which means no callback and it prevents from unwrapping the oldest entry.
OnRemove : nil ,
// OnRemoveWithReason is a callback fired when the oldest entry is removed because of its expiration time or no space left
// for the new entry, or because delete was called. A constant representing the reason will be passed through.
// Default value is nil which means no callback and it prevents from unwrapping the oldest entry.
// Ignored if OnRemove is specified.
OnRemoveWithReason : nil ,
}
cache , initErr := bigcache . New ( context . Background (), config )
if initErr != nil {
log . Fatal ( initErr )
}
cache . Set ( "my-unique-key" , [] byte ( "value" ))
if entry , err := cache . Get ( "my-unique-key" ); err == nil {
fmt . Println ( string ( entry ))
}LifeWindow & CleanWindow LifeWindow adalah waktu. Setelah waktu itu, entri dapat disebut mati tetapi tidak dihapus.
CleanWindow adalah waktu. Setelah waktu itu, semua entri yang mati akan dihapus, tetapi bukan entri yang masih memiliki kehidupan.
Tiga cache dibandingkan: BigCache, Freecache dan Map. Tes benchmark dilakukan dengan menggunakan CPU I7-6700K @ 4.00GHz dengan 32GB RAM pada Ubuntu 18.04 LTS (5.2.12-050212-Generic).
Kode sumber tolok ukur dapat ditemukan di sini
go version
go version go1.13 linux/amd64
go test -bench=. -benchmem -benchtime=4s ./... -timeout 30m
goos: linux
goarch: amd64
pkg: github.com/allegro/bigcache/v3/caches_bench
BenchmarkMapSet-8 12999889 376 ns/op 199 B/op 3 allocs/op
BenchmarkConcurrentMapSet-8 4355726 1275 ns/op 337 B/op 8 allocs/op
BenchmarkFreeCacheSet-8 11068976 703 ns/op 328 B/op 2 allocs/op
BenchmarkBigCacheSet-8 10183717 478 ns/op 304 B/op 2 allocs/op
BenchmarkMapGet-8 16536015 324 ns/op 23 B/op 1 allocs/op
BenchmarkConcurrentMapGet-8 13165708 401 ns/op 24 B/op 2 allocs/op
BenchmarkFreeCacheGet-8 10137682 690 ns/op 136 B/op 2 allocs/op
BenchmarkBigCacheGet-8 11423854 450 ns/op 152 B/op 4 allocs/op
BenchmarkBigCacheSetParallel-8 34233472 148 ns/op 317 B/op 3 allocs/op
BenchmarkFreeCacheSetParallel-8 34222654 268 ns/op 350 B/op 3 allocs/op
BenchmarkConcurrentMapSetParallel-8 19635688 240 ns/op 200 B/op 6 allocs/op
BenchmarkBigCacheGetParallel-8 60547064 86.1 ns/op 152 B/op 4 allocs/op
BenchmarkFreeCacheGetParallel-8 50701280 147 ns/op 136 B/op 3 allocs/op
BenchmarkConcurrentMapGetParallel-8 27353288 175 ns/op 24 B/op 2 allocs/op
PASS
ok github.com/allegro/bigcache/v3/caches_bench 256.257sMenulis dan dibaca di BigCache lebih cepat daripada di Freecache. Menulis ke peta adalah yang paling lambat.
go version
go version go1.13 linux/amd64
go run caches_gc_overhead_comparison.go
Number of entries: 20000000
GC pause for bigcache: 1.506077ms
GC pause for freecache: 5.594416ms
GC pause for map: 9.347015ms go version
go version go1.13 linux/arm64
go run caches_gc_overhead_comparison.go
Number of entries: 20000000
GC pause for bigcache: 22.382827ms
GC pause for freecache: 41.264651ms
GC pause for map: 72.236853ms
Tes menunjukkan berapa lama jeda GC untuk cache yang diisi dengan 20mln entri. Bigcache dan Freecache memiliki waktu jeda GC yang sangat mirip.
Anda dapat menemukan memori sistem yang melaporkan apa yang tampaknya merupakan peningkatan eksponensial, namun ini adalah perilaku yang diharapkan. GO runtime mengalokasikan memori dalam potongan atau 'rentang' dan akan menginformasikan OS ketika mereka tidak lagi diharuskan dengan mengubah keadaan mereka menjadi 'menganggur'. 'Rentang' akan tetap menjadi bagian dari penggunaan sumber daya proses sampai OS perlu menggunakan kembali alamat tersebut. Bacaan lebih lanjut tersedia di sini.
BigCache bergantung pada optimasi yang disajikan dalam 1,5 versi GO (masalah-9477). Optimalisasi ini menyatakan bahwa jika peta tanpa pointer dalam kunci dan nilai digunakan maka GC akan menghilangkan isinya. Oleh karena itu, BigCache menggunakan map[uint64]uint32 di mana kunci hash dan nilai adalah offset entri.
Entri disimpan dalam irisan byte, untuk menghilangkan GC lagi. Ukuran irisan byte dapat tumbuh menjadi gigabytes tanpa dampak pada kinerja karena GC hanya akan melihat penunjuk tunggal untuk itu.
Bigcache tidak menangani tabrakan. Ketika item baru dimasukkan dan hash bertabrakan dengan item yang disimpan sebelumnya, item baru menimpa nilai yang sebelumnya tersimpan.
Kedua cache menyediakan fitur inti yang sama tetapi mereka mengurangi overhead GC dengan cara yang berbeda. BigCache bergantung pada map[uint64]uint32 , Freecache mengimplementasikan pemetaannya sendiri yang dibangun di atas irisan untuk mengurangi jumlah petunjuk.
Hasil dari tes benchmark disajikan di atas. Salah satu keuntungan dari BigCache dibandingkan Freecache adalah bahwa Anda tidak perlu mengetahui ukuran cache terlebih dahulu, karena ketika BigCache penuh, itu dapat mengalokasikan memori tambahan untuk entri baru alih -alih menimpa yang sudah ada seperti yang dilakukan Freecache saat ini. Betapapun ukuran maksimumnya di BigCache juga dapat diatur, periksa hardmaxcachesize.
Paket ini juga mencakup implementasi HTTP BigCache yang mudah digunakan, yang dapat ditemukan di paket server.
Bigcache Genesis dijelaskan dalam Allegro. Posting Blog Teknik: Menulis layanan cache yang sangat cepat di Go
BigCache dirilis di bawah lisensi Apache 2.0 (lihat lisensi)
