refactor(share): use atomic.Int64 and fix 'racy' bugs (celestiaorg#3478)

Moving from raw `int64` and atomic operations to the `atomic.Int64`
type. As a result fixing a few places where we were accessing atomic
variables non-atomically. Which isn't a problem 'cause there were only
reads BUT these places would reported by race detector and fail our
tests for not a big reason.

share/ipld/namespace_data.go

@@ -54,14 +54,16 @@ type NamespaceData struct {
 
 func NewNamespaceData(maxShares int, namespace share.Namespace, options ...Option) *NamespaceData {
 	data := &NamespaceData{
-		// we don't know where in the tree the leaves in the namespace are,
-		// so we keep track of the bounds to return the correct slice
-		// maxShares acts as a sentinel to know if we find any leaves
-		bounds:    fetchedBounds{int64(maxShares), 0},
 		maxShares: maxShares,
 		namespace: namespace,
 	}
 
+	// we don't know where in the tree the leaves in the namespace are,
+	// so we keep track of the bounds to return the correct slice
+	// maxShares acts as a sentinel to know if we find any leaves
+	data.bounds.lowest.Store(int64(maxShares))
+	data.bounds.highest.Store(0)
+
 	for _, opt := range options {
 		opt(data)
 	}
@@ -107,7 +109,7 @@ func (n *NamespaceData) addLeaf(pos int, nd ipld.Node) {
 
 // noLeaves checks that there are no leaves under the given root in the given namespace.
 func (n *NamespaceData) noLeaves() bool {
-	return n.bounds.lowest == int64(n.maxShares)
+	return n.bounds.lowest.Load() == int64(n.maxShares)
 }
 
 type direction int
@@ -138,7 +140,7 @@ func (n *NamespaceData) Leaves() []ipld.Node {
 	if n.leaves == nil || n.noLeaves() || n.isAbsentNamespace.Load() {
 		return nil
 	}
-	return n.leaves[n.bounds.lowest : n.bounds.highest+1]
+	return n.leaves[n.bounds.lowest.Load() : n.bounds.highest.Load()+1]
 }
 
 // Proof returns proofs within the bounds in case if `WithProofs` option was passed,
@@ -160,17 +162,17 @@ func (n *NamespaceData) Proof() *nmt.Proof {
 
 	if n.isAbsentNamespace.Load() {
 		proof := nmt.NewAbsenceProof(
-			int(n.bounds.lowest),
-			int(n.bounds.highest)+1,
+			int(n.bounds.lowest.Load()),
+			int(n.bounds.highest.Load())+1,
 			nodes,
 			NamespacedSha256FromCID(n.absenceProofLeaf.Cid()),
 			NMTIgnoreMaxNamespace,
 		)
 		return &proof
 	}
 	proof := nmt.NewInclusionProof(
-		int(n.bounds.lowest),
-		int(n.bounds.highest)+1,
+		int(n.bounds.lowest.Load()),
+		int(n.bounds.highest.Load())+1,
 		nodes,
 		NMTIgnoreMaxNamespace,
 	)
@@ -311,24 +313,24 @@ func (n *NamespaceData) collectNDWithProofs(j job, links []*ipld.Link) []job {
 }
 
 type fetchedBounds struct {
-	lowest  int64
-	highest int64
+	lowest  atomic.Int64
+	highest atomic.Int64
 }
 
 // update checks if the passed index is outside the current bounds,
 // and updates the bounds atomically if it extends them.
 func (b *fetchedBounds) update(index int64) {
-	lowest := atomic.LoadInt64(&b.lowest)
+	lowest := b.lowest.Load()
 	// try to write index to the lower bound if appropriate, and retry until the atomic op is successful
 	// CAS ensures that we don't overwrite if the bound has been updated in another goroutine after the
 	// comparison here
-	for index < lowest && !atomic.CompareAndSwapInt64(&b.lowest, lowest, index) {
-		lowest = atomic.LoadInt64(&b.lowest)
+	for index < lowest && !b.lowest.CompareAndSwap(lowest, index) {
+		lowest = b.lowest.Load()
 	}
 	// we always run both checks because element can be both the lower and higher bound
 	// for example, if there is only one share in the namespace
-	highest := atomic.LoadInt64(&b.highest)
-	for index > highest && !atomic.CompareAndSwapInt64(&b.highest, highest, index) {
-		highest = atomic.LoadInt64(&b.highest)
+	highest := b.highest.Load()
+	for index > highest && !b.highest.CompareAndSwap(highest, index) {
+		highest = b.highest.Load()
 	}
 }