Haxmap Versions Save

handle edge case to prevent panic during map initialization https://github.com/alphadose/haxmap/pull/44 @semihbkgr

This release is all thanks to @semihbkgr 🙏

• Added GetAndDel function similar to golang concurrent map's LoadAndDelete https://github.com/alphadose/haxmap/pull/31
• JSON encoding support https://github.com/alphadose/haxmap/pull/29
• Critical bug fixed with Set operation after Delete https://github.com/alphadose/haxmap/pull/34
• No more unnecessary resizing https://github.com/alphadose/haxmap/pull/36
• Fix logic of fillrate computation https://github.com/alphadose/haxmap/pull/38

• Add atomic CompareAndSwap and Swap APIs https://github.com/alphadose/haxmap/issues/18
• Improve deletion performance via lazily deleting nodes https://github.com/alphadose/haxmap/issues/17
• Add GetOrCompute API which works similar to GetOrSet but the value is computed from a constructor which is called only once https://github.com/alphadose/haxmap/issues/16

Add GetOrSet() API same as golang's sync.Map.LoadOrStore https://github.com/alphadose/haxmap/issues/15

Fix deadlock when multiple goroutines are trying to delete the same linked-list node https://github.com/alphadose/haxmap/commit/f4885e7522f138036dabe14c8eec0e5b7b66d0a6

• Support go 1.18 and above @StandoffVenus https://github.com/alphadose/haxmap/pull/13
• Fix concurrent deletion issue https://github.com/alphadose/haxmap/issues/14
• Add bulk deletion feature map.Del(keyA, keyB, keyC...)

• Fix bug in delete operation https://github.com/alphadose/haxmap/issues/11
• Fix deadlock bug during Set() https://github.com/alphadose/haxmap/issues/7 https://github.com/alphadose/haxmap/issues/8
• Update ForEach() API to match golang's sync.Map.Range() https://github.com/alphadose/haxmap/issues/10

Notes

• Improve hashing performance by switching to pure arithmetic and bitmasking for known key sizes

Benchmarks

Benchmarks were performed against golang sync.Map and the latest cornelk-hashmap

All results were computed from benchstat of 20 runs

1. Concurrent Reads Only

name                         time/op
HaxMapReadsOnly-8            7.13µs ± 5%
GoSyncMapReadsOnly-8         22.4µs ± 2%
CornelkMapReadsOnly-8        8.28µs ± 1%

2. Concurrent Reads with Writes

name                         time/op
HaxMapReadsWithWrites-8      8.44µs ± 5%
GoSyncMapReadsWithWrites-8   26.1µs ± 2%
CornelkMapReadsWithWrites-8  9.55µs ± 2%

name                         alloc/op
HaxMapReadsWithWrites-8      1.22kB ± 6%
GoSyncMapReadsWithWrites-8   6.06kB ± 6%
CornelkMapReadsWithWrites-8  1.56kB ± 5%

name                         allocs/op
HaxMapReadsWithWrites-8         152 ± 6%
GoSyncMapReadsWithWrites-8      562 ± 6%
CornelkMapReadsWithWrites-8     195 ± 5%

Notes

• Hashing performance improvement by type-casting keys to arrays instead of slices as seen in this commit https://github.com/alphadose/haxmap/commit/eee8abe05d83c726178d921bdb498baf74a6e671
• Fixed tests for 32 bit platforms (tested on my raspberry pi running 32 bit raspian OS)
• Make map growth policy synchronous

Benchmarks

Benchmarks were performed against golang sync.Map and cornelk-hashmap-v1.0.6 for sample 20 cases

1. Concurrent Reads Only

name                         time/op
HaxMapReadsOnly-8            8.75µs ± 9%
GoSyncMapReadsOnly-8         22.0µs ±11%
CornelkMapReadsOnly-8        9.20µs ±10%

2. Concurrent Reads with Writes

name                         time/op
HaxMapReadsWithWrites-8      10.0µs ± 9%
GoSyncMapReadsWithWrites-8   24.8µs ±11%
CornelkMapReadsWithWrites-8  10.5µs ± 9%

name                         alloc/op
HaxMapReadsWithWrites-8      1.29kB ± 6%
GoSyncMapReadsWithWrites-8   6.20kB ± 5%
CornelkMapReadsWithWrites-8  1.59kB ±10%

name                         allocs/op
HaxMapReadsWithWrites-8         161 ± 4%
GoSyncMapReadsWithWrites-8      574 ± 5%
CornelkMapReadsWithWrites-8     198 ±10%

Notes

Performance gain obtained by inlining hash function assignments

Benchmarks

Benchmarks were performed against golang sync.Map and the latest cornelk-hashmap

All results were computed from benchstat of 20 runs (code available here)

1. Concurrent Reads Only

name                         time/op
HaxMapReadsOnly-8            9.18µs ±12%
GoSyncMapReadsOnly-8         22.5µs ± 5%
CornelkMapReadsOnly-8        10.4µs ± 4%

name                         alloc/op
HaxMapReadsOnly-8             0.00B
GoSyncMapReadsOnly-8          0.00B
CornelkMapReadsOnly-8         0.00B

name                         allocs/op
HaxMapReadsOnly-8              0.00
GoSyncMapReadsOnly-8           0.00
CornelkMapReadsOnly-8          0.00

2. Concurrent Reads with Writes

name                         time/op
HaxMapReadsWithWrites-8      10.5µs ± 7%
GoSyncMapReadsWithWrites-8   25.6µs ± 7%
CornelkMapReadsWithWrites-8  12.3µs ± 6%

name                         alloc/op
HaxMapReadsWithWrites-8      1.28kB ± 5%
GoSyncMapReadsWithWrites-8   6.23kB ± 6%
CornelkMapReadsWithWrites-8  5.89kB ± 7%

name                         allocs/op
HaxMapReadsWithWrites-8         159 ± 5%
GoSyncMapReadsWithWrites-8      577 ± 6%
CornelkMapReadsWithWrites-8     210 ± 8%

From the above results it is evident that haxmap takes the least time, memory and allocations in all cases