-
Notifications
You must be signed in to change notification settings - Fork 2.5k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Add SyncMap package and use it for graph stop/remove
This greatly simplifies the locking around these two functions, and things end up looking a lot more elegant. This should prevent the race flakes we were seeing before. Fixes #25289 Signed-off-by: Matt Heon <mheon@redhat.com>
- Loading branch information
Showing
2 changed files
with
103 additions
and
33 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,82 @@ | ||
| package syncmap | ||
|
|
||
| import ( | ||
| "maps" | ||
| "sync" | ||
| ) | ||
|
|
||
| // A SyncMap is a map of a string to a generified value which is locked for safe | ||
| // access from multiple threads. | ||
| // It is effectively a generic version of Golang's standard library sync.Map. | ||
| // Admittedly, that has optimizations for multithreading performance that we do | ||
| // not here; thus, SyncMap should not be used in truly performance sensitive | ||
| // areas, but places where code cleanliness is more important than raw | ||
| // performance. | ||
| // SyncMap should always be passed by reference, not by value, to ensure thread | ||
| // safety is maintained. | ||
| type SyncMap[K comparable, V any] struct { | ||
| data map[K]V | ||
| lock sync.Mutex | ||
| } | ||
|
|
||
| // NewSyncMap generates a new, empty SyncMap | ||
| func New[K comparable, V any]() *SyncMap[K,V] { | ||
| toReturn := new(SyncMap[K,V]) | ||
| toReturn.data = make(map[K]V) | ||
|
|
||
| return toReturn | ||
| } | ||
|
|
||
| // Put adds an entry into the map | ||
| func (m *SyncMap[K, V]) Put(key K, value V) { | ||
| m.lock.Lock() | ||
| defer m.lock.Unlock() | ||
|
|
||
| m.data[key] = value | ||
| } | ||
|
|
||
| // Get retrieves an entry from the map. | ||
| // Semantic match Golang map semantics - the bool represents whether the key | ||
| // exists, and the empty value of T will be returned if the key does not exist. | ||
| func (m *SyncMap[K, V]) Get(key K) (V, bool) { | ||
| m.lock.Lock() | ||
| defer m.lock.Unlock() | ||
|
|
||
| value, exists := m.data[key] | ||
|
|
||
| return value, exists | ||
| } | ||
|
|
||
| // Exists returns true if a key exists in the map. | ||
| func (m *SyncMap[K, V]) Exists(key K) bool { | ||
| m.lock.Lock() | ||
| defer m.lock.Unlock() | ||
|
|
||
| _, ok := m.data[key] | ||
|
|
||
| return ok | ||
| } | ||
|
|
||
| // Delete removes an entry from the map. | ||
| func (m *SyncMap[K, V]) Delete(key K) { | ||
| m.lock.Lock() | ||
| defer m.lock.Unlock() | ||
|
|
||
| delete(m.data, key) | ||
| } | ||
|
|
||
| // ToMap returns a shallow copy of the underlying data of the SyncMap. | ||
| func (m *SyncMap[K, V]) ToMap() map[K]V { | ||
| m.lock.Lock() | ||
| defer m.lock.Unlock() | ||
|
|
||
| return maps.Clone(m.data) | ||
| } | ||
|
|
||
| // Underlying returns a reference to the underlying storage of the SyncMap. | ||
| // Once Underlying has been called, the SyncMap is NO LONGER THREAD SAFE. | ||
| // If thread safety is still required, the shallow-copy offered by ToMap() | ||
| // should be used instead. | ||
| func (m *SyncMap[K, V]) Underlying() map[K]V { | ||
| return m.data | ||
| } |