Btree config update, refactoring

Author: praserx

.travis.yml

@@ -1,8 +1,7 @@
 language: go
 go:
-  - 1.12.4
-  - 1.13.8
-  - 1.14
+  - 1.16.8
+  - 1.17.1
 
 script:
   - go test ./...

README.md

@@ -27,9 +27,28 @@ if _, err := cache.Get([]byte("key")); err != nil {
 For this benchmark was created memory with following specs: `2048 bytes per record`, `2048 records per shard`, `128 shards (max)`. The 2048 bytes was set.
 
 ```
-BenchmarkCacheNewMedium-4    	    1000	   1012982 ns/op	 4416184 B/op	    4139 allocs/op
-BenchmarkCacheSetMedium-4    	 5000000	       327 ns/op	      16 B/op	       0 allocs/op
-BenchmarkCacheGetMedium-4    	30000000	        48.5 ns/op	       0 B/op	       0 allocs/op
+BenchmarkCacheNewMedium-12       	     314	   3804726 ns/op	22686418 B/op	   12402 allocs/op
+BenchmarkCacheSetMedium-12       	 1845970	       664.2 ns/op	     129 B/op	       5 allocs/op
+BenchmarkCacheGetMedium-12       	 5701435	       209.1 ns/op	      16 B/op	       1 allocs/op
 ```
 
 *If you want do some special bencharking, go ahead.*
+
+### AtomicCache vs. BigCache vs. FreeCache vs. HashicorpCache
+
+**SET**
+```
+BenchmarkAtomicCacheSet-12       	 2402160	       519.6 ns/op	     153 B/op	       6 allocs/op
+BenchmarkBigCacheSet-12          	 4021484	       376.7 ns/op	      66 B/op	       1 allocs/op
+BenchmarkFreeCacheSet-12         	10443246	       100.8 ns/op	       0 B/op	       0 allocs/op
+BenchmarkHashicorpCacheSet-12    	 2490759	       498.4 ns/op	     150 B/op	       5 allocs/op
+```
+
+**GET**
+```
+BenchmarkAtomicCacheGet-12       	 6300744	       187.6 ns/op	      16 B/op	       1 allocs/op
+BenchmarkBigCacheGet-12          	 3798052	       322.5 ns/op	      37 B/op	       2 allocs/op
+BenchmarkFreeCacheGet-12         	 9000188	       127.0 ns/op	      24 B/op	       1 allocs/op
+BenchmarkHashicorpCacheGet-12    	 3039728	       405.8 ns/op	       7 B/op	       0 allocs/op
+
+```

cache.go

@@ -11,9 +11,9 @@ import (
 
 // Internal cache errors
 var (
-	ErrNotFound   = errors.New("Record not found")
-	ErrDataLimit  = errors.New("Can't create new record, it violates data limit")
-	ErrFullMemory = errors.New("Can't create new rocord, memory is full")
+	ErrNotFound   = errors.New("record not found")
+	ErrDataLimit  = errors.New("cannot create new record: it violates data limit")
+	ErrFullMemory = errors.New("cannot create new rocord: memory is full")
 )
 
 // Constans below are used for shard section identification.
@@ -116,7 +116,7 @@ func New(opts ...Option) *AtomicCache {
 	cache := &AtomicCache{}
 
 	// Init lookup table
-	cache.lookup = btree.NewWithStringComparator(3)
+	cache.lookup = btree.NewWithStringComparator(16)
 
 	// Init small shards section
 	initShardsSection(&cache.smallShards, options.MaxShardsSmall, options.MaxRecords, options.RecordSizeSmall)
@@ -141,7 +141,7 @@ func New(opts ...Option) *AtomicCache {
 func initShardsSection(shardsSection *ShardsLookup, maxShards, maxRecords, recordSize uint32) {
 	var shardIndex uint32
 
-	shardsSection.shards = make([]*Shard, maxShards, maxShards)
+	shardsSection.shards = make([]*Shard, maxShards)
 	for i := uint32(0); i < maxShards; i++ {
 		shardsSection.shardsAvail = append(shardsSection.shardsAvail, i)
 	}
@@ -246,7 +246,7 @@ func (a *AtomicCache) releaseShard(shardSectionID uint8, shard uint32) bool {
 		return false
 	}
 
-	if shardSection.shards[shard].IsEmpty() == true {
+	if shardSection.shards[shard].IsEmpty() {
 		shardSection.shards[shard] = nil
 
 		shardSection.shardsAvail = append(shardSection.shardsAvail, shard)

cache_test.go

@@ -191,23 +191,23 @@ func benchmarkCacheGet(recordCount, dataSize uint32, b *testing.B) {
 	}
 }
 
-func benchmarkAdvanced(recordCount, dataSize uint32, b *testing.B) {
-	var data []byte
-	cache := New(OptionMaxRecords(recordCount))
+// func benchmarkAdvanced(recordCount, dataSize uint32, b *testing.B) {
+// 	var data []byte
+// 	cache := New(OptionMaxRecords(recordCount))
 
-	for i := uint32(0); i < dataSize; i++ {
-		data = append(data, 1)
-	}
+// 	for i := uint32(0); i < dataSize; i++ {
+// 		data = append(data, 1)
+// 	}
 
-	cache.Set([]byte{byte(1)}, data, 0)
+// 	cache.Set([]byte{byte(1)}, data, 0)
 
-	b.ReportAllocs()
-	b.ResetTimer()
+// 	b.ReportAllocs()
+// 	b.ResetTimer()
 
-	for n := 0; n < b.N; n++ {
-		cache.Get([]byte{byte(1)})
-	}
-}
+// 	for n := 0; n < b.N; n++ {
+// 		cache.Get([]byte{byte(1)})
+// 	}
+// }
 
 func BenchmarkCacheNewSmall(b *testing.B) {
 	benchmarkCacheNew(512, b)

record.go

@@ -28,7 +28,6 @@ func NewRecord(size uint32) *Record {
 // record data property and size is set.
 func (r *Record) Set(data []byte) {
 	dataLength := uint32(len(data))
-
 	r.Lock() // Lock for writing and reading
 	if dataLength > r.size {
 		r.alloc = r.size
@@ -42,12 +41,11 @@ func (r *Record) Set(data []byte) {
 // Get returns bytes based on size of virtual allocation. It means that it
 // returns only specific count of bytes, based on alloc property. If array on
 // output is empty, then record is not exists.
-func (r *Record) Get() []byte {
+func (r *Record) Get() (data []byte) {
 	r.RLock() // Lock for reading
-	data := r.data[:r.alloc]
+	data = r.data[:r.alloc]
 	r.RUnlock() // Unlock for reading
-
-	return data
+	return
 }
 
 // Free set alloc property to 0. Through this action, we empty memory of record
@@ -59,17 +57,17 @@ func (r *Record) Free() {
 }
 
 // GetAllocated returns size of allocated bytes.
-func (r *Record) GetAllocated() uint32 {
+func (r *Record) GetAllocated() (size uint32) {
 	r.RLock() // Lock for reading
-	data := r.alloc
+	size = r.alloc
 	r.RUnlock() // Unlock for reading
-	return data
+	return
 }
 
 // GetDataLength returns real size of allocated bytes in memory.
-func (r *Record) GetDataLength() uint32 {
+func (r *Record) GetDataLength() (size uint32) {
 	r.RLock() // Lock for reading
-	data := uint32(len(r.data))
+	size = uint32(len(r.data))
 	r.RUnlock() // Unlock for reading
-	return data
+	return
 }

shard.go

@@ -33,27 +33,23 @@ func NewShard(slotCount, slotSize uint32) *Shard {
 
 // Set store data as a record and decrease slotAvail count. On output it return
 // index of used slot.
-func (s *Shard) Set(data []byte) uint32 {
-	var index uint32
-
+func (s *Shard) Set(data []byte) (i uint32) {
 	s.Lock() // Lock for writing and reading
-	index, s.slotAvail = s.slotAvail[0], s.slotAvail[1:]
+	i, s.slotAvail = s.slotAvail[0], s.slotAvail[1:]
 	s.Unlock() // Unlock for writing and reading
-
 	s.RLock()
-	s.slots[index].Set(data)
+	s.slots[i].Set(data)
 	s.RUnlock()
-
-	return index
+	return
 }
 
 // Get returns bytes from shard memory based on index. If array on output is
 // empty, then record is not exists.
-func (s *Shard) Get(index uint32) []byte {
+func (s *Shard) Get(index uint32) (v []byte) {
 	s.RLock()
-	value := s.slots[index].Get()
+	v = s.slots[index].Get()
 	s.RUnlock()
-	return value
+	return
 }
 
 // Free empty memory specified by index on input and increase slot counter.
@@ -65,23 +61,20 @@ func (s *Shard) Free(index uint32) {
 }
 
 // GetSlotsAvail returns number of available memory slots of shard.
-func (s *Shard) GetSlotsAvail() uint32 {
+func (s *Shard) GetSlotsAvail() (cnt uint32) {
 	s.RLock()
-	slotAvailCnt := uint32(len(s.slotAvail))
+	cnt = uint32(len(s.slotAvail))
 	s.RUnlock()
-	return slotAvailCnt
+	return
 }
 
 // IsEmpty return true if shard has no record registered. Otherwise return
 // false.
-func (s *Shard) IsEmpty() bool {
-	result := false
-
+func (s *Shard) IsEmpty() (result bool) {
 	s.RLock()
 	if len(s.slotAvail) == len(s.slots) {
 		result = true
 	}
 	s.RUnlock()
-
-	return result
+	return
 }