Package: internal/concurrent

package concurrent Import Path internal/concurrent (on go.dev) Dependency Relation imports 6 packages, and imported by one package Involved Source Files hashtriemap.go Package-Level Type Names (total 6, in which 1 is exported) /* sort exporteds by: alphabet | popularity */ type HashTrieMap[K, V] (struct) Type Parameters: K: comparable V: comparable HashTrieMap is an implementation of a concurrent hash-trie. The implementation is designed around frequent loads, but offers decent performance for stores and deletes as well, especially if the map is larger. It's primary use-case is the unique package, but can be used elsewhere as well. Fields (total 5, none are exported) /* 5 unexporteds ... *//* 5 unexporteds: */ keyEqual equalFunc keyHash hashFunc root *indirect[K, V] seed uintptr valEqual equalFunc Methods (total 6, in which 4 are exported) (*HashTrieMap[K, V]) All() func(yield func(K, V) bool) All returns an iter.Seq2 that produces all key-value pairs in the map. The enumeration does not represent any consistent snapshot of the map, but is guaranteed to visit each unique key-value pair only once. It is safe to operate on the tree during iteration. No particular enumeration order is guaranteed. (*HashTrieMap[K, V]) CompareAndDelete(key K, old V) (deleted bool) CompareAndDelete deletes the entry for key if its value is equal to old. If there is no current value for key in the map, CompareAndDelete returns false (even if the old value is the nil interface value). (*HashTrieMap[K, V]) Load(key K) (value V, ok bool) Load returns the value stored in the map for a key, or nil if no value is present. The ok result indicates whether value was found in the map. (*HashTrieMap[K, V]) LoadOrStore(key K, value V) (result V, loaded bool) LoadOrStore returns the existing value for the key if present. Otherwise, it stores and returns the given value. The loaded result is true if the value was loaded, false if stored. /* 2 unexporteds ... *//* 2 unexporteds: */ (*HashTrieMap[K, V]) expand(oldEntry, newEntry *entry[K, V], newHash uintptr, hashShift uint, parent *indirect[K, V]) *node[K, V] expand takes oldEntry and newEntry whose hashes conflict from bit 64 down to hashShift and produces a subtree of indirect nodes to hold the two new entries. (*HashTrieMap[K, V]) iter(i *indirect[K, V], yield func(key K, value V) bool) bool As Outputs Of (at least one exported) func NewHashTrieMap[K, V]() *HashTrieMap[K, V] As Types Of (only one, which is unexported) /* one unexported ... *//* one unexported: */ var unique.uniqueMaps *concurrent.HashTrieMap[...] /* 5 unexporteds ... *//* 5 unexporteds: */ type entry[K, V] (struct) Type Parameters: K: comparable V: comparable entry is a leaf node in the hash-trie. Fields (total 5, none are exported) /* 5 unexporteds ... *//* 5 unexporteds: */ key K node node[K, V] node.isEntry bool overflow atomic.Pointer[entry[K, V]] // Overflow for hash collisions. value V Methods (total 4, none are exported) /* 4 unexporteds ... *//* 4 unexporteds: */ (*entry[K, V]) compareAndDelete(key K, value V, keyEqual, valEqual equalFunc) (*entry[K, V], bool) compareAndDelete deletes an entry in the overflow chain if both the key and value compare equal. Returns the new entry chain and whether or not anything was deleted. compareAndDelete must be called under the mutex of the indirect node which e is a child of. (*entry[K, V]) entry() *entry[K, V] (*entry[K, V]) indirect() *indirect[K, V] (*entry[K, V]) lookup(key K, equal equalFunc) (V, bool) As Outputs Of (at least one unexported) /* at least one unexported ... *//* at least one unexported: */ func newEntryNode[K, V](key K, value V) *entry[K, V] As Inputs Of (at least one unexported) /* at least one unexported ... *//* at least one unexported: */ func (*HashTrieMap)[K, V].expand(oldEntry, newEntry *entry[K, V], newHash uintptr, hashShift uint, parent *indirect[K, V]) *node[K, V] type equalFunc (func) type hashFunc (func) type indirect[K, V] (struct) Type Parameters: K: comparable V: comparable indirect is an internal node in the hash-trie. Fields (total 6, none are exported) /* 6 unexporteds ... *//* 6 unexporteds: */ children [16]atomic.Pointer[node[K, V]] dead atomic.Bool mu sync.Mutex // Protects mutation to children and any children that are entry nodes. node node[K, V] node.isEntry bool parent *indirect[K, V] Methods (total 3, none are exported) /* 3 unexporteds ... *//* 3 unexporteds: */ (*indirect[K, V]) empty() bool (*indirect[K, V]) entry() *entry[K, V] (*indirect[K, V]) indirect() *indirect[K, V] As Outputs Of (at least one unexported) /* at least one unexported ... *//* at least one unexported: */ func newIndirectNode[K, V](parent *indirect[K, V]) *indirect[K, V] As Inputs Of (at least 3, none are exported) /* 3+ unexporteds ... *//* 3+ unexporteds: */ func newIndirectNode[K, V](parent *indirect[K, V]) *indirect[K, V] func (*HashTrieMap)[K, V].expand(oldEntry, newEntry *entry[K, V], newHash uintptr, hashShift uint, parent *indirect[K, V]) *node[K, V] func (*HashTrieMap)[K, V].iter(i *indirect[K, V], yield func(key K, value V) bool) bool type node[K, V] (struct) Type Parameters: K: comparable V: comparable node is the header for a node. It's polymorphic and is actually either an entry or an indirect. Fields (only one, which is unexported) /* one unexported ... *//* one unexported: */ isEntry bool Methods (total 2, neither is exported) /* 2 unexporteds ... *//* 2 unexporteds: */ (*node[K, V]) entry() *entry[K, V] (*node[K, V]) indirect() *indirect[K, V] As Outputs Of (at least one unexported) /* at least one unexported ... *//* at least one unexported: */ func (*HashTrieMap)[K, V].expand(oldEntry, newEntry *entry[K, V], newHash uintptr, hashShift uint, parent *indirect[K, V]) *node[K, V] Package-Level Functions (total 3, in which 1 is exported) func NewHashTrieMap[K, V]() *HashTrieMap[K, V] Type Parameters: K: comparable V: comparable NewHashTrieMap creates a new HashTrieMap for the provided key and value. /* 2 unexporteds ... *//* 2 unexporteds: */ func newEntryNode[K, V](key K, value V) *entry[K, V] Type Parameters: K: comparable V: comparable func newIndirectNode[K, V](parent *indirect[K, V]) *indirect[K, V] Type Parameters: K: comparable V: comparable Package-Level Constants (total 3, none are exported) /* 3 unexporteds ... *//* 3 unexporteds: */ const nChildren = 16 const nChildrenLog2 = 4 16 children. This seems to be the sweet spot for load performance: any smaller and we lose out on 50% or more in CPU performance. Any larger and the returns are minuscule (~1% improvement for 32 children). const nChildrenMask = 15

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.