diff --git a/bucket.go b/bucket.go deleted file mode 100644 index 6a4171c..0000000 --- a/bucket.go +++ /dev/null @@ -1,103 +0,0 @@ -package cuckoo - -type entry[K, V any] struct { - key K - value V -} - -type slot[K, V any] struct { - entry[K, V] - occupied bool -} - -type bucket[K, V any] struct { - hash Hash[K] - slots []slot[K, V] - capacity, size uint64 - compare EqualFunc[K] -} - -// location determines where in the bucket a certain key would be placed. If the -// capacity is 0, this will panic. -func (b bucket[K, V]) location(key K) uint64 { - return b.hash(key) % b.capacity -} - -func (b bucket[K, V]) get(key K) (value V, found bool) { - if b.capacity == 0 { - return - } - - slot := b.slots[b.location(key)] - return slot.value, slot.occupied && b.compare(slot.key, key) -} - -func (b *bucket[K, V]) drop(key K) (occupied bool) { - if b.capacity == 0 { - return - } - - slot := &b.slots[b.location(key)] - - if slot.occupied && b.compare(slot.key, key) { - slot.occupied = false - b.size-- - return true - } - - return false -} - -func (b *bucket[K, V]) resize(capacity uint64) { - b.slots = make([]slot[K, V], capacity) - b.capacity = capacity - b.size = 0 -} - -func (b bucket[K, V]) update(key K, value V) (updated bool) { - if b.capacity == 0 { - return - } - - slot := &b.slots[b.location(key)] - - if slot.occupied && b.compare(slot.key, key) { - slot.value = value - return true - } - - return false -} - -func (b *bucket[K, V]) evict(insertion entry[K, V]) (evicted entry[K, V], eviction bool) { - if b.capacity == 0 { - return insertion, true - } - - slot := &b.slots[b.location(insertion.key)] - - if !slot.occupied { - slot.entry = insertion - slot.occupied = true - b.size++ - return - } - - if b.compare(slot.key, insertion.key) { - slot.value = insertion.value - return - } - - insertion, slot.entry = slot.entry, insertion - return insertion, true -} - -func newBucket[K, V any](capacity uint64, hash Hash[K], compare EqualFunc[K]) bucket[K, V] { - return bucket[K, V]{ - hash: hash, - capacity: capacity, - compare: compare, - size: 0, - slots: make([]slot[K, V], capacity), - } -} diff --git a/hash_table.go b/hash_table.go new file mode 100644 index 0000000..9e037ac --- /dev/null +++ b/hash_table.go @@ -0,0 +1,237 @@ +package cuckoo + +import ( + "fmt" + "iter" + "math/bits" + "strings" +) + +// A HashTable is hash table that uses cuckoo hashing to resolve collision. Create +// one with [NewTable]. Or if you want more granularity, use [NewTableBy] or +// [NewCustomTable]. +type HashTable[K, V any] struct { + tableA, tableB table[K, V] + growthFactor uint64 + minLoadFactor float64 +} + +// TotalCapacity returns the number of slots allocated for the [HashTable]. To get the +// number of slots filled, look at [HashTable.Size]. +func (t *HashTable[K, V]) TotalCapacity() uint64 { + return t.tableA.capacity + t.tableB.capacity +} + +// Size returns how many slots are filled in the [HashTable]. +func (t *HashTable[K, V]) Size() int { + return int(t.tableA.size + t.tableB.size) +} + +func log2(n uint64) (m int) { + return max(0, bits.Len64(n)-1) +} + +func (t *HashTable[K, V]) maxEvictions() int { + return 3 * log2(t.TotalCapacity()) +} + +func (t *HashTable[K, V]) load() float64 { + // When there are no slots in the table, we still treat the load as 100%. + // Every slot in the table is full. + if t.TotalCapacity() == 0 { + return 1.0 + } + + return float64(t.Size()) / float64(t.TotalCapacity()) +} + +// resize clears all buckets, changes the sizes of them to a specific capacity, +// and fills them back up again. It is a helper function for [HashTable.grow] and +// [HashTable.shrink]; use them instead. +func (t *HashTable[K, V]) resize(capacity uint64) error { + entries := make([]entry[K, V], 0, t.Size()) + for k, v := range t.Entries() { + entries = append(entries, entry[K, V]{k, v}) + } + + t.tableA.resize(capacity) + t.tableB.resize(capacity) + + for _, entry := range entries { + if err := t.Put(entry.key, entry.value); err != nil { + return err + } + } + + return nil +} + +// grow increases the table's capacity by the [HashTable.growthFactor]. If the +// capacity is 0, it increases it to 1. +func (t *HashTable[K, V]) grow() error { + var newCapacity uint64 + + if t.TotalCapacity() == 0 { + newCapacity = 1 + } else { + newCapacity = t.tableA.capacity * t.growthFactor + } + + return t.resize(newCapacity) +} + +// shrink reduces the table's capacity by the [HashTable.growthFactor]. It may +// reduce it down to 0. +func (t *HashTable[K, V]) shrink() error { + return t.resize(t.tableA.capacity / t.growthFactor) +} + +// Get fetches the value for a key in the [HashTable]. Returns an error if no value +// is found. +func (t *HashTable[K, V]) Get(key K) (value V, err error) { + if item, ok := t.tableA.get(key); ok { + return item, nil + } + + if item, ok := t.tableB.get(key); ok { + return item, nil + } + + return value, fmt.Errorf("key '%v' not found", key) +} + +// Has returns true if a key has a value in the table. +func (t *HashTable[K, V]) Has(key K) (exists bool) { + _, err := t.Get(key) + return err == nil +} + +// Put sets the value for a key. Returns error if its value cannot be set. +func (t *HashTable[K, V]) Put(key K, value V) (err error) { + if t.tableA.update(key, value) { + return nil + } + + if t.tableB.update(key, value) { + return nil + } + + entry, eviction := entry[K, V]{key, value}, false + for range t.maxEvictions() { + if entry, eviction = t.tableA.evict(entry); !eviction { + return nil + } + + if entry, eviction = t.tableB.evict(entry); !eviction { + return nil + } + } + + if t.load() < t.minLoadFactor { + return fmt.Errorf("bad hash: resize on load %d/%d = %f", t.Size(), t.TotalCapacity(), t.load()) + } + + if err := t.grow(); err != nil { + return err + } + + return t.Put(entry.key, entry.value) +} + +// Drop removes a value for a key in the table. Returns an error if its value +// cannot be removed. +func (t *HashTable[K, V]) Drop(key K) (err error) { + t.tableA.drop(key) + t.tableB.drop(key) + + if t.load() < t.minLoadFactor { + return t.shrink() + } + + return nil +} + +// Entries returns an unordered sequence of all key-value pairs in the table. +func (t *HashTable[K, V]) Entries() iter.Seq2[K, V] { + return func(yield func(K, V) bool) { + for _, slot := range t.tableA.slots { + if slot.occupied { + if !yield(slot.key, slot.value) { + return + } + } + } + + for _, slot := range t.tableB.slots { + if slot.occupied { + if !yield(slot.key, slot.value) { + return + } + } + } + } +} + +// String returns the entries of the table as a string in the format: +// "table[k1:v1 h2:v2 ...]". +func (t *HashTable[K, V]) String() string { + var sb strings.Builder + sb.WriteString("table[") + + first := true + for k, v := range t.Entries() { + if !first { + sb.WriteString(" ") + } + + fmt.Fprintf(&sb, "%v:%v", k, v) + first = false + } + + sb.WriteString("]") + return sb.String() +} + +// NewCustomTable creates a [HashTable] with custom [Hash] and [EqualFunc] +// functions, along with any [Option] the user provides. +func NewCustomTable[K, V any](hashA, hashB Hash[K], compare EqualFunc[K], options ...Option) *HashTable[K, V] { + settings := &settings{ + growthFactor: DefaultGrowthFactor, + bucketSize: DefaultCapacity, + minLoadFactor: defaultMinimumLoad, + } + + for _, option := range options { + option(settings) + } + + return &HashTable[K, V]{ + growthFactor: settings.growthFactor, + minLoadFactor: settings.minLoadFactor, + tableA: newTable[K, V](settings.bucketSize, hashA, compare), + tableB: newTable[K, V](settings.bucketSize, hashB, compare), + } +} + +func pipe[X, Y, Z any](a func(X) Y, b func(Y) Z) func(X) Z { + return func(x X) Z { return b(a(x)) } +} + +// NewTableBy creates a [HashTable] for any key type by using keyFunc to derive a +// comparable key. Two keys with the same derived key are treated as equal. +func NewTableBy[K, V any, C comparable](keyFunc func(K) C, options ...Option) *HashTable[K, V] { + return NewCustomTable[K, V]( + pipe(keyFunc, NewDefaultHash[C]()), + pipe(keyFunc, NewDefaultHash[C]()), + func(a, b K) bool { return keyFunc(a) == keyFunc(b) }, + options..., + ) +} + +// NewTable creates a [HashTable] using the default [Hash] and [EqualFunc]. Use +// the [Option] functions to configure its behavior. Note that this constructor +// is only provided for comparable keys. For arbitrary keys, consider +// [NewTableBy] or [NewCustomTable]. +func NewTable[K comparable, V any](options ...Option) *HashTable[K, V] { + return NewCustomTable[K, V](NewDefaultHash[K](), NewDefaultHash[K](), DefaultEqualFunc[K], options...) +} diff --git a/table.go b/table.go index 922aa81..c676a5d 100644 --- a/table.go +++ b/table.go @@ -1,237 +1,103 @@ package cuckoo -import ( - "fmt" - "iter" - "math/bits" - "strings" -) - -// A Table is hash table that uses cuckoo hashing to resolve collision. Create -// one with [NewTable]. Or if you want more granularity, use [NewTableBy] or -// [NewCustomTable]. -type Table[K, V any] struct { - bucketA, bucketB bucket[K, V] - growthFactor uint64 - minLoadFactor float64 +type entry[K, V any] struct { + key K + value V } -// TotalCapacity returns the number of slots allocated for the [Table]. To get the -// number of slots filled, look at [Table.Size]. -func (t Table[K, V]) TotalCapacity() uint64 { - return t.bucketA.capacity + t.bucketB.capacity +type slot[K, V any] struct { + entry[K, V] + occupied bool } -// Size returns how many slots are filled in the [Table]. -func (t Table[K, V]) Size() int { - return int(t.bucketA.size + t.bucketB.size) +type table[K, V any] struct { + hash Hash[K] + slots []slot[K, V] + capacity, size uint64 + compare EqualFunc[K] } -func log2(n uint64) (m int) { - return max(0, bits.Len64(n)-1) +// location determines where in the bucket a certain key would be placed. If the +// capacity is 0, this will panic. +func (t table[K, V]) location(key K) uint64 { + return t.hash(key) % t.capacity } -func (t Table[K, V]) maxEvictions() int { - return 3 * log2(t.TotalCapacity()) -} - -func (t Table[K, V]) load() float64 { - // When there are no slots in the table, we still treat the load as 100%. - // Every slot in the table is full. - if t.TotalCapacity() == 0 { - return 1.0 +func (t table[K, V]) get(key K) (value V, found bool) { + if t.capacity == 0 { + return } - return float64(t.Size()) / float64(t.TotalCapacity()) + slot := t.slots[t.location(key)] + return slot.value, slot.occupied && t.compare(slot.key, key) } -// resize clears all buckets, changes the sizes of them to a specific capacity, -// and fills them back up again. It is a helper function for [Table.grow] and -// [Table.shrink]; use them instead. -func (t *Table[K, V]) resize(capacity uint64) error { - entries := make([]entry[K, V], 0, t.Size()) - for k, v := range t.Entries() { - entries = append(entries, entry[K, V]{k, v}) +func (t *table[K, V]) drop(key K) (occupied bool) { + if t.capacity == 0 { + return } - t.bucketA.resize(capacity) - t.bucketB.resize(capacity) + slot := &t.slots[t.location(key)] - for _, entry := range entries { - if err := t.Put(entry.key, entry.value); err != nil { - return err - } + if slot.occupied && t.compare(slot.key, key) { + slot.occupied = false + t.size-- + return true } - return nil + return false } -// grow increases the table's capacity by the [Table.growthFactor]. If the -// capacity is 0, it increases it to 1. -func (t *Table[K, V]) grow() error { - var newCapacity uint64 - - if t.TotalCapacity() == 0 { - newCapacity = 1 - } else { - newCapacity = t.bucketA.capacity * t.growthFactor - } - - return t.resize(newCapacity) +func (t *table[K, V]) resize(capacity uint64) { + t.slots = make([]slot[K, V], capacity) + t.capacity = capacity + t.size = 0 } -// shrink reduces the table's capacity by the [Table.growthFactor]. It may -// reduce it down to 0. -func (t *Table[K, V]) shrink() error { - return t.resize(t.bucketA.capacity / t.growthFactor) +func (t table[K, V]) update(key K, value V) (updated bool) { + if t.capacity == 0 { + return + } + + slot := &t.slots[t.location(key)] + + if slot.occupied && t.compare(slot.key, key) { + slot.value = value + return true + } + + return false } -// Get fetches the value for a key in the [Table]. Returns an error if no value -// is found. -func (t Table[K, V]) Get(key K) (value V, err error) { - if item, ok := t.bucketA.get(key); ok { - return item, nil +func (t *table[K, V]) evict(insertion entry[K, V]) (evicted entry[K, V], eviction bool) { + if t.capacity == 0 { + return insertion, true } - if item, ok := t.bucketB.get(key); ok { - return item, nil + slot := &t.slots[t.location(insertion.key)] + + if !slot.occupied { + slot.entry = insertion + slot.occupied = true + t.size++ + return } - return value, fmt.Errorf("key '%v' not found", key) + if t.compare(slot.key, insertion.key) { + slot.value = insertion.value + return + } + + insertion, slot.entry = slot.entry, insertion + return insertion, true } -// Has returns true if a key has a value in the table. -func (t Table[K, V]) Has(key K) (exists bool) { - _, err := t.Get(key) - return err == nil -} - -// Put sets the value for a key. Returns error if its value cannot be set. -func (t *Table[K, V]) Put(key K, value V) (err error) { - if t.bucketA.update(key, value) { - return nil - } - - if t.bucketB.update(key, value) { - return nil - } - - entry, eviction := entry[K, V]{key, value}, false - for range t.maxEvictions() { - if entry, eviction = t.bucketA.evict(entry); !eviction { - return nil - } - - if entry, eviction = t.bucketB.evict(entry); !eviction { - return nil - } - } - - if t.load() < t.minLoadFactor { - return fmt.Errorf("bad hash: resize on load %d/%d = %f", t.Size(), t.TotalCapacity(), t.load()) - } - - if err := t.grow(); err != nil { - return err - } - - return t.Put(entry.key, entry.value) -} - -// Drop removes a value for a key in the table. Returns an error if its value -// cannot be removed. -func (t *Table[K, V]) Drop(key K) (err error) { - t.bucketA.drop(key) - t.bucketB.drop(key) - - if t.load() < t.minLoadFactor { - return t.shrink() - } - - return nil -} - -// Entries returns an unordered sequence of all key-value pairs in the table. -func (t Table[K, V]) Entries() iter.Seq2[K, V] { - return func(yield func(K, V) bool) { - for _, slot := range t.bucketA.slots { - if slot.occupied { - if !yield(slot.key, slot.value) { - return - } - } - } - - for _, slot := range t.bucketB.slots { - if slot.occupied { - if !yield(slot.key, slot.value) { - return - } - } - } +func newTable[K, V any](capacity uint64, hash Hash[K], compare EqualFunc[K]) table[K, V] { + return table[K, V]{ + hash: hash, + capacity: capacity, + compare: compare, + size: 0, + slots: make([]slot[K, V], capacity), } } - -// String returns the entries of the table as a string in the format: -// "table[k1:v1 h2:v2 ...]". -func (t Table[K, V]) String() string { - var sb strings.Builder - sb.WriteString("table[") - - first := true - for k, v := range t.Entries() { - if !first { - sb.WriteString(" ") - } - - fmt.Fprintf(&sb, "%v:%v", k, v) - first = false - } - - sb.WriteString("]") - return sb.String() -} - -// NewCustomTable creates a [Table] with custom [Hash] and [EqualFunc] -// functions, along with any [Option] the user provides. -func NewCustomTable[K, V any](hashA, hashB Hash[K], compare EqualFunc[K], options ...Option) *Table[K, V] { - settings := &settings{ - growthFactor: DefaultGrowthFactor, - bucketSize: DefaultCapacity, - minLoadFactor: defaultMinimumLoad, - } - - for _, option := range options { - option(settings) - } - - return &Table[K, V]{ - growthFactor: settings.growthFactor, - minLoadFactor: settings.minLoadFactor, - bucketA: newBucket[K, V](settings.bucketSize, hashA, compare), - bucketB: newBucket[K, V](settings.bucketSize, hashB, compare), - } -} - -func pipe[X, Y, Z any](a func(X) Y, b func(Y) Z) func(X) Z { - return func(x X) Z { return b(a(x)) } -} - -// NewTableBy creates a [Table] for any key type by using keyFunc to derive a -// comparable key. Two keys with the same derived key are treated as equal. -func NewTableBy[K, V any, C comparable](keyFunc func(K) C, options ...Option) *Table[K, V] { - return NewCustomTable[K, V]( - pipe(keyFunc, NewDefaultHash[C]()), - pipe(keyFunc, NewDefaultHash[C]()), - func(a, b K) bool { return keyFunc(a) == keyFunc(b) }, - options..., - ) -} - -// NewTable creates a [Table] using the default [Hash] and [EqualFunc]. Use -// the [Option] functions to configure its behavior. Note that this constructor -// is only provided for comparable keys. For arbitrary keys, consider -// [NewTableBy] or [NewCustomTable]. -func NewTable[K comparable, V any](options ...Option) *Table[K, V] { - return NewCustomTable[K, V](NewDefaultHash[K](), NewDefaultHash[K](), DefaultEqualFunc[K], options...) -}