prevent concurrent deletions on same node

Author: alphadose

list.go

@@ -2,8 +2,11 @@ package haxmap
 
 import "sync/atomic"
 
-// marks if a node is deleted or not
-const deleted uint32 = 1
+// states denoting whether a node is deleted or not
+const (
+	notDeleted uint32 = iota
+	deleted
+)
 
 // Below implementation is a lock-free linked list based on https://www.cl.cam.ac.uk/research/srg/netos/papers/2001-caslists.pdf by Timothy L. Harris
 // Performance improvements suggested in https://arxiv.org/pdf/2010.15755.pdf were also added
@@ -97,8 +100,9 @@ func (self *element[K, V]) search(c uintptr, key K) (*element[K, V], *element[K,
 
 // remove marks a node for deletion
 // the node will be removed in the next iteration via `element.next()`
-func (self *element[K, V]) remove() {
-	atomic.StoreUint32(&self.deleted, deleted)
+// CAS ensures each node can be marked for deletion exactly once
+func (self *element[K, V]) remove() bool {
+	return atomic.CompareAndSwapUint32(&self.deleted, notDeleted, deleted)
 }
 
 // if current element is deleted

map.go

@@ -89,8 +89,7 @@ func (m *Map[K, V]) Del(keys ...K) {
 		}
 		for ; existing != nil && existing.keyHash <= h; existing = existing.next() {
 			if existing.key == keys[0] {
-				if !existing.isDeleted() {
-					existing.remove()               // mark node for lazy removal on next pass
+				if existing.remove() { // mark node for lazy removal on next pass
 					m.removeItemFromIndex(existing) // remove node from map index
 				}
 				return
@@ -118,8 +117,7 @@ func (m *Map[K, V]) Del(keys ...K) {
 
 		for elem != nil && iter < size {
 			if elem.keyHash == delQ[iter].keyHash && elem.key == delQ[iter].key {
-				if !elem.isDeleted() {
-					elem.remove()               // mark node for lazy removal on next pass
+				if elem.remove() { // mark node for lazy removal on next pass
 					m.removeItemFromIndex(elem) // remove node from map index
 				}
 				iter++