gtsocial-umbx

hashmap.go (9483B)

---

 // Package hashmap provides a lock-free and thread-safe HashMap.
 package hashmap
 
 import (
 	"bytes"
 	"fmt"
 	"reflect"
 	"strconv"
 	"sync/atomic"
 	"unsafe"
 )
 
 // Map implements a read optimized hash map.
 type Map[Key hashable, Value any] struct {
 	hasher     func(Key) uintptr
 	store      atomic.Pointer[store[Key, Value]] // pointer to a map instance that gets replaced if the map resizes
 	linkedList *List[Key, Value]                 // key sorted linked list of elements
 	// resizing marks a resizing operation in progress.
 	// this is using uintptr instead of atomic.Bool to avoid using 32 bit int on 64 bit systems
 	resizing atomic.Uintptr
 }
 
 // New returns a new map instance.
 func New[Key hashable, Value any]() *Map[Key, Value] {
 	return NewSized[Key, Value](defaultSize)
 }
 
 // NewSized returns a new map instance with a specific initialization size.
 func NewSized[Key hashable, Value any](size uintptr) *Map[Key, Value] {
 	m := &Map[Key, Value]{}
 	m.allocate(size)
 	m.setDefaultHasher()
 	return m
 }
 
 // SetHasher sets a custom hasher.
 func (m *Map[Key, Value]) SetHasher(hasher func(Key) uintptr) {
 	m.hasher = hasher
 }
 
 // Len returns the number of elements within the map.
 func (m *Map[Key, Value]) Len() int {
 	return m.linkedList.Len()
 }
 
 // Get retrieves an element from the map under given hash key.
 func (m *Map[Key, Value]) Get(key Key) (Value, bool) {
 	hash := m.hasher(key)
 
 	for element := m.store.Load().item(hash); element != nil; element = element.Next() {
 		if element.keyHash == hash && element.key == key {
 			return element.Value(), true
 		}
 
 		if element.keyHash > hash {
 			return *new(Value), false
 		}
 	}
 	return *new(Value), false
 }
 
 // GetOrInsert returns the existing value for the key if present.
 // Otherwise, it stores and returns the given value.
 // The returned bool is true if the value was loaded, false if stored.
 func (m *Map[Key, Value]) GetOrInsert(key Key, value Value) (Value, bool) {
 	hash := m.hasher(key)
 	var newElement *ListElement[Key, Value]
 
 	for {
 		for element := m.store.Load().item(hash); element != nil; element = element.Next() {
 			if element.keyHash == hash && element.key == key {
 				actual := element.Value()
 				return actual, true
 			}
 
 			if element.keyHash > hash {
 				break
 			}
 		}
 
 		if newElement == nil { // allocate only once
 			newElement = &ListElement[Key, Value]{
 				key:     key,
 				keyHash: hash,
 			}
 			newElement.value.Store(&value)
 		}
 
 		if m.insertElement(newElement, hash, key, value) {
 			return value, false
 		}
 	}
 }
 
 // FillRate returns the fill rate of the map as a percentage integer.
 func (m *Map[Key, Value]) FillRate() int {
 	store := m.store.Load()
 	count := int(store.count.Load())
 	l := len(store.index)
 	return (count * 100) / l
 }
 
 // Del deletes the key from the map and returns whether the key was deleted.
 func (m *Map[Key, Value]) Del(key Key) bool {
 	hash := m.hasher(key)
 	store := m.store.Load()
 	element := store.item(hash)
 
 	for ; element != nil; element = element.Next() {
 		if element.keyHash == hash && element.key == key {
 			m.deleteElement(element)
 			m.linkedList.Delete(element)
 			return true
 		}
 
 		if element.keyHash > hash {
 			return false
 		}
 	}
 	return false
 }
 
 // Insert sets the value under the specified key to the map if it does not exist yet.
 // If a resizing operation is happening concurrently while calling Insert, the item might show up in the map
 // after the resize operation is finished.
 // Returns true if the item was inserted or false if it existed.
 func (m *Map[Key, Value]) Insert(key Key, value Value) bool {
 	hash := m.hasher(key)
 	var (
 		existed, inserted bool
 		element           *ListElement[Key, Value]
 	)
 
 	for {
 		store := m.store.Load()
 		searchStart := store.item(hash)
 
 		if !inserted { // if retrying after insert during grow, do not add to list again
 			element, existed, inserted = m.linkedList.Add(searchStart, hash, key, value)
 			if existed {
 				return false
 			}
 			if !inserted {
 				continue // a concurrent add did interfere, try again
 			}
 		}
 
 		count := store.addItem(element)
 		currentStore := m.store.Load()
 		if store != currentStore { // retry insert in case of insert during grow
 			continue
 		}
 
 		if m.isResizeNeeded(store, count) && m.resizing.CompareAndSwap(0, 1) {
 			go m.grow(0, true)
 		}
 		return true
 	}
 }
 
 // Set sets the value under the specified key to the map. An existing item for this key will be overwritten.
 // If a resizing operation is happening concurrently while calling Set, the item might show up in the map
 // after the resize operation is finished.
 func (m *Map[Key, Value]) Set(key Key, value Value) {
 	hash := m.hasher(key)
 
 	for {
 		store := m.store.Load()
 		searchStart := store.item(hash)
 
 		element, added := m.linkedList.AddOrUpdate(searchStart, hash, key, value)
 		if !added {
 			continue // a concurrent add did interfere, try again
 		}
 
 		count := store.addItem(element)
 		currentStore := m.store.Load()
 		if store != currentStore { // retry insert in case of insert during grow
 			continue
 		}
 
 		if m.isResizeNeeded(store, count) && m.resizing.CompareAndSwap(0, 1) {
 			go m.grow(0, true)
 		}
 		return
 	}
 }
 
 // Grow resizes the map to a new size, the size gets rounded up to next power of 2.
 // To double the size of the map use newSize 0.
 // This function returns immediately, the resize operation is done in a goroutine.
 // No resizing is done in case of another resize operation already being in progress.
 func (m *Map[Key, Value]) Grow(newSize uintptr) {
 	if m.resizing.CompareAndSwap(0, 1) {
 		go m.grow(newSize, true)
 	}
 }
 
 // String returns the map as a string, only hashed keys are printed.
 func (m *Map[Key, Value]) String() string {
 	buffer := bytes.NewBufferString("")
 	buffer.WriteRune('[')
 
 	first := m.linkedList.First()
 	item := first
 
 	for item != nil {
 		if item != first {
 			buffer.WriteRune(',')
 		}
 		fmt.Fprint(buffer, item.keyHash)
 		item = item.Next()
 	}
 	buffer.WriteRune(']')
 	return buffer.String()
 }
 
 // Range calls f sequentially for each key and value present in the map.
 // If f returns false, range stops the iteration.
 func (m *Map[Key, Value]) Range(f func(Key, Value) bool) {
 	item := m.linkedList.First()
 
 	for item != nil {
 		value := item.Value()
 		if !f(item.key, value) {
 			return
 		}
 		item = item.Next()
 	}
 }
 
 func (m *Map[Key, Value]) allocate(newSize uintptr) {
 	m.linkedList = NewList[Key, Value]()
 	if m.resizing.CompareAndSwap(0, 1) {
 		m.grow(newSize, false)
 	}
 }
 
 func (m *Map[Key, Value]) isResizeNeeded(store *store[Key, Value], count uintptr) bool {
 	l := uintptr(len(store.index)) // l can't be 0 as it gets initialized in New()
 	fillRate := (count * 100) / l
 	return fillRate > maxFillRate
 }
 
 func (m *Map[Key, Value]) insertElement(element *ListElement[Key, Value], hash uintptr, key Key, value Value) bool {
 	var existed, inserted bool
 
 	for {
 		store := m.store.Load()
 		searchStart := store.item(element.keyHash)
 
 		if !inserted { // if retrying after insert during grow, do not add to list again
 			_, existed, inserted = m.linkedList.Add(searchStart, hash, key, value)
 			if existed {
 				return false
 			}
 
 			if !inserted {
 				continue // a concurrent add did interfere, try again
 			}
 		}
 
 		count := store.addItem(element)
 		currentStore := m.store.Load()
 		if store != currentStore { // retry insert in case of insert during grow
 			continue
 		}
 
 		if m.isResizeNeeded(store, count) && m.resizing.CompareAndSwap(0, 1) {
 			go m.grow(0, true)
 		}
 		return true
 	}
 }
 
 // deleteElement deletes an element from index.
 func (m *Map[Key, Value]) deleteElement(element *ListElement[Key, Value]) {
 	for {
 		store := m.store.Load()
 		index := element.keyHash >> store.keyShifts
 		ptr := (*unsafe.Pointer)(unsafe.Pointer(uintptr(store.array) + index*intSizeBytes))
 
 		next := element.Next()
 		if next != nil && element.keyHash>>store.keyShifts != index {
 			next = nil // do not set index to next item if it's not the same slice index
 		}
 		atomic.CompareAndSwapPointer(ptr, unsafe.Pointer(element), unsafe.Pointer(next))
 
 		currentStore := m.store.Load()
 		if store == currentStore { // check that no resize happened
 			break
 		}
 	}
 }
 
 func (m *Map[Key, Value]) grow(newSize uintptr, loop bool) {
 	defer m.resizing.CompareAndSwap(1, 0)
 
 	for {
 		currentStore := m.store.Load()
 		if newSize == 0 {
 			newSize = uintptr(len(currentStore.index)) << 1
 		} else {
 			newSize = roundUpPower2(newSize)
 		}
 
 		index := make([]*ListElement[Key, Value], newSize)
 		header := (*reflect.SliceHeader)(unsafe.Pointer(&index))
 
 		newStore := &store[Key, Value]{
 			keyShifts: strconv.IntSize - log2(newSize),
 			array:     unsafe.Pointer(header.Data), // use address of slice data storage
 			index:     index,
 		}
 
 		m.fillIndexItems(newStore) // initialize new index slice with longer keys
 
 		m.store.Store(newStore)
 
 		m.fillIndexItems(newStore) // make sure that the new index is up-to-date with the current state of the linked list
 
 		if !loop {
 			return
 		}
 
 		// check if a new resize needs to be done already
 		count := uintptr(m.Len())
 		if !m.isResizeNeeded(newStore, count) {
 			return
 		}
 		newSize = 0 // 0 means double the current size
 	}
 }
 
 func (m *Map[Key, Value]) fillIndexItems(store *store[Key, Value]) {
 	first := m.linkedList.First()
 	item := first
 	lastIndex := uintptr(0)
 
 	for item != nil {
 		index := item.keyHash >> store.keyShifts
 		if item == first || index != lastIndex { // store item with smallest hash key for every index
 			store.addItem(item)
 			lastIndex = index
 		}
 		item = item.Next()
 	}
 }