use acquire-release ordering

Thanks vtjnash!
#45 (comment)

Author: kalmarek

src/Perms/perm_images.jl

@@ -44,36 +44,36 @@ AP.__unsafe_image(n::Integer, σ::Perm) = oftype(n, @inbounds σ.images[n])
 function Base.copy(p::Perm)
     imgs = copy(p.images)
     q = typeof(p)(imgs; check = false)
-    if isdefined(p, :inv, :sequentially_consistent)
-        inv_imgs = copy(@atomic(p.inv).images)
+    if isdefined(p, :inv, :acquire)
+        inv_imgs = copy(p.inv.images)
         q⁻¹ = typeof(p)(inv_imgs; check = false)
-        @atomic q.inv = q⁻¹
-        @atomic q⁻¹.inv = q
+        @atomic :release q⁻¹.inv = q
+        @atomiconce :release :acquire q.inv = q⁻¹
     end
     return q
 end
 
 function Base.inv(σ::Perm)
-    if !isdefined(σ, :inv, :sequentially_consistent)
+    if !isdefined(σ, :inv, :acquire)
         if isone(σ)
-            @atomic σ.inv = σ
+            @atomiconce :release :acquire σ.inv = σ
         else
             σ⁻¹ = typeof(σ)(invperm(σ.images); check = false)
-            # we don't want to end up with two copies of inverse σ floating around
-            if !isdefined(σ, :inv, :sequentially_consistent)
-                @atomic σ.inv = σ⁻¹
-                @atomic σ⁻¹.inv = σ
-            end
+            # this order is important:
+            # fuly initialize the "local" inverse first and only then
+            # update σ to make the local inverse visible globally
+            @atomic :release σ⁻¹.inv = σ
+            @atomiconce :release :acquire σ.inv = σ⁻¹
         end
     end
     return σ.inv
 end
 
 function AP.cycles(σ::Perm)
-    if !isdefined(σ, :cycles, :sequentially_consistent)
+    if !isdefined(σ, :cycles, :acquire)
         cdec = AP.CycleDecomposition(σ)
         # we can afford producing more than one cycle decomposition
-        @atomic σ.cycles = cdec
+        @atomiconce :release :acquire σ.cycles = cdec
     end
     return σ.cycles
 end

src/group_interface.jl

@@ -3,9 +3,9 @@
 Base.one(G::PermGroup{P}) where {P} = Permutation(one(P), G)
 
 function GroupsCore.order(::Type{T}, G::AbstractPermutationGroup) where {T}
-    if !isdefined(G, :order, :sequentially_consistent)
-        ord = order(StabilizerChain(G))
-        @atomic G.order = ord
+    if !isdefined(G, :order, :acquire)
+        ord = order(BigInt, StabilizerChain(G))
+        @atomiconce :release :acquire G.order = ord
     end
     return convert(T, G.order)
 end

src/perm_group.jl

@@ -90,12 +90,9 @@ The subsequent calls just return the cached data structure.
 """
 
 function StabilizerChain(G::PermGroup{P,T}) where {P,T}
-    if !isdefined(G, :stabchain, :sequentially_consistent)
+    if !isdefined(G, :stabchain, :acquire)
         stabchain = schreier_sims(T, __gens_raw(G))
-        # this may take some time, so let's check again
-        if !isdefined(G, :stabchain, :sequentially_consistent)
-            @atomic G.stabchain = stabchain
-        end
+        @atomiconce :release :acquire G.stabchain = stabchain
     end
     return G.stabchain
 end