improve(syncmap): weaken fences on immutable path

vectrixdevelops · vectrixdevelops · commit 06be362d7a7c · 2025-10-30T23:50:54.000+13:00
diff --git a/collections-fastutil/src/main/java-templates/space/vectrix/sync/collections/fastutil/{{key}}2ObjectSyncMap.java.peb b/collections-fastutil/src/main/java-templates/space/vectrix/sync/collections/fastutil/{{key}}2ObjectSyncMap.java.peb
@@ -379,12 +379,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
     if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && node.key == key) {
-        return node.reference().valueExists();
+        return node.referencePlain().valueExists();
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && node.key == key) {
-          return node.reference().valueExists();
+          return node.referencePlain().valueExists();
         }
       }
     }
@@ -439,12 +439,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
     if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && node.key == key) {
-        return node.reference().value();
+        return node.referencePlain().value();
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && node.key == key) {
-          return node.reference().value();
+          return node.referencePlain().value();
         }
       }
     }
@@ -501,12 +501,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
     if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && node.key == key) {
-        return node.reference().valueOr(defaultValue);
+        return node.referencePlain().valueOr(defaultValue);
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && node.key == key) {
-          return node.reference().valueOr(defaultValue);
+          return node.referencePlain().valueOr(defaultValue);
         }
       }
     }
@@ -1579,7 +1579,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
       Node<V> node;
       while((node = traverser.advanceNode()) != null) {
-        final Object current = node.reference().get();
+        final Object current = node.referencePlain().get();
         if(current == null || current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;
 
         consumer.accept(node.key, (V) current);
@@ -1597,7 +1597,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
       Node<V> node; long count = 0L;
       while((node = traverser.advanceNode()) != null) {
-        final ObjectReference reference = node.reference();
+        final ObjectReference reference = node.referencePlain();
         Object current = reference.get();
         for(; ; ) {
           if(current == null || current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;
@@ -2586,7 +2586,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
 
       Node<V> node;
       while((node = this.advanceNode()) != null) {
-        final Object current = node.reference().get();
+        final Object current = node.referencePlain().get();
         if(current == null || current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;
 
         this.next = new MapEntry(node.key, (V) current);
@@ -2614,7 +2614,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {
     /* package */ final @Nullable Node<V> advanceNode() {
       Node<V> node;
       if((node = this.next) != null) {
-        node = node.next();
+        node = node.nextPlain();
       }
 
       for(; ; ) {
diff --git a/collections/src/main/java/space/vectrix/sync/collections/SyncMap.java b/collections/src/main/java/space/vectrix/sync/collections/SyncMap.java
@@ -403,12 +403,12 @@ public boolean containsKey(final Object key) {
     K nodeKey;
     if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-        return node.reference().valueExists();
+        return node.referencePlain().valueExists();
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-          return node.reference().valueExists();
+          return node.referencePlain().valueExists();
         }
       }
     }
@@ -457,12 +457,12 @@ public boolean containsKey(final Object key) {
     K nodeKey;
     if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-        return node.reference().value();
+        return node.referencePlain().value();
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-          return node.reference().value();
+          return node.referencePlain().value();
         }
       }
     }
@@ -512,12 +512,12 @@ public V getOrDefault(final Object key, final V defaultValue) {
 
     if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {
       if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-        return node.reference().valueOr(defaultValue);
+        return node.referencePlain().valueOr(defaultValue);
       }
 
-      while((node = node.next()) != null) {
+      while((node = node.nextPlain()) != null) {
         if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
-          return node.reference().valueOr(defaultValue);
+          return node.referencePlain().valueOr(defaultValue);
         }
       }
     }
@@ -1457,7 +1457,7 @@ public void forEach(final BiConsumer<? super K, ? super V> action) {
 
       Node<K, V> node;
       while((node = traverser.advanceNode()) != null) {
-        final Object current = node.reference().get();
+        final Object current = node.referencePlain().get();
         if(current == null || current == SyncMap.EXPUNGED) continue;
 
         action.accept(node.key, (V) current);
@@ -1475,7 +1475,7 @@ public void clear() {
 
       Node<K, V> node; long count = 0L;
       while((node = traverser.advanceNode()) != null) {
-        final ObjectReference reference = node.reference();
+        final ObjectReference reference = node.referencePlain();
         Object current = reference.get();
         for(; ; ) {
           if(current == null || current == SyncMap.EXPUNGED) continue;
@@ -2450,7 +2450,7 @@ private void advanceEntry() {
 
       Node<K, V> node;
       while((node = this.advanceNode()) != null) {
-        final Object current = node.reference().get();
+        final Object current = node.referencePlain().get();
         if(current == null || current == SyncMap.EXPUNGED) continue;
 
         this.next = new MapEntry(node.key, (V) current);
@@ -2479,7 +2479,7 @@ private void advanceEntry() {
     /* package */ final @Nullable Node<K, V> advanceNode() {
       Node<K, V> node;
       if((node = this.next) != null) {
-        node = node.next();
+        node = node.nextPlain();
       }
 
       for(; ; ) {

Original file line number	Diff line number	Diff line change
`@@ -379,12 +379,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`379`	`379`
`380`	`380`	`if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {`
`381`	`381`	`if(node.hash == hash && node.key == key) {`
`382`		`- return node.reference().valueExists();`
	`382`	`+ return node.referencePlain().valueExists();`
`383`	`383`	`}`
`384`	`384`
`385`		`- while((node = node.next()) != null) {`
	`385`	`+ while((node = node.nextPlain()) != null) {`
`386`	`386`	`if(node.hash == hash && node.key == key) {`
`387`		`- return node.reference().valueExists();`
	`387`	`+ return node.referencePlain().valueExists();`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`	`}`
`@@ -439,12 +439,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`439`	`439`
`440`	`440`	`if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {`
`441`	`441`	`if(node.hash == hash && node.key == key) {`
`442`		`- return node.reference().value();`
	`442`	`+ return node.referencePlain().value();`
`443`	`443`	`}`
`444`	`444`
`445`		`- while((node = node.next()) != null) {`
	`445`	`+ while((node = node.nextPlain()) != null) {`
`446`	`446`	`if(node.hash == hash && node.key == key) {`
`447`		`- return node.reference().value();`
	`447`	`+ return node.referencePlain().value();`
`448`	`448`	`}`
`449`	`449`	`}`
`450`	`450`	`}`
`@@ -501,12 +501,12 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`501`	`501`
`502`	`502`	`if(length > 0 && (node = {{ key }}2ObjectSyncMap.getNode(table, (length - 1) & hash)) != null) {`
`503`	`503`	`if(node.hash == hash && node.key == key) {`
`504`		`- return node.reference().valueOr(defaultValue);`
	`504`	`+ return node.referencePlain().valueOr(defaultValue);`
`505`	`505`	`}`
`506`	`506`
`507`		`- while((node = node.next()) != null) {`
	`507`	`+ while((node = node.nextPlain()) != null) {`
`508`	`508`	`if(node.hash == hash && node.key == key) {`
`509`		`- return node.reference().valueOr(defaultValue);`
	`509`	`+ return node.referencePlain().valueOr(defaultValue);`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`	`}`
`@@ -1579,7 +1579,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`1579`	`1579`
`1580`	`1580`	`Node<V> node;`
`1581`	`1581`	`while((node = traverser.advanceNode()) != null) {`
`1582`		`- final Object current = node.reference().get();`
	`1582`	`+ final Object current = node.referencePlain().get();`
`1583`	`1583`	`if(current == null \|\| current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;`
`1584`	`1584`
`1585`	`1585`	`consumer.accept(node.key, (V) current);`
`@@ -1597,7 +1597,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`1597`	`1597`
`1598`	`1598`	`Node<V> node; long count = 0L;`
`1599`	`1599`	`while((node = traverser.advanceNode()) != null) {`
`1600`		`- final ObjectReference reference = node.reference();`
	`1600`	`+ final ObjectReference reference = node.referencePlain();`
`1601`	`1601`	`Object current = reference.get();`
`1602`	`1602`	`for(; ; ) {`
`1603`	`1603`	`if(current == null \|\| current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;`
`@@ -2586,7 +2586,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`2586`	`2586`
`2587`	`2587`	`Node<V> node;`
`2588`	`2588`	`while((node = this.advanceNode()) != null) {`
`2589`		`- final Object current = node.reference().get();`
	`2589`	`+ final Object current = node.referencePlain().get();`
`2590`	`2590`	`if(current == null \|\| current == {{ key }}2ObjectSyncMap.EXPUNGED) continue;`
`2591`	`2591`
`2592`	`2592`	`this.next = new MapEntry(node.key, (V) current);`
`@@ -2614,7 +2614,7 @@ public class {{ key }}2ObjectSyncMap<V> extends Abstract{{ key }}2ObjectMap<V> {`
`2614`	`2614`	`/* package */ final @Nullable Node<V> advanceNode() {`
`2615`	`2615`	`Node<V> node;`
`2616`	`2616`	`if((node = this.next) != null) {`
`2617`		`- node = node.next();`
	`2617`	`+ node = node.nextPlain();`
`2618`	`2618`	`}`
`2619`	`2619`
`2620`	`2620`	`for(; ; ) {`
Original file line number	Diff line number	Diff line change
`@@ -403,12 +403,12 @@ public boolean containsKey(final Object key) {`
`403`	`403`	`K nodeKey;`
`404`	`404`	`if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {`
`405`	`405`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`406`		`- return node.reference().valueExists();`
	`406`	`+ return node.referencePlain().valueExists();`
`407`	`407`	`}`
`408`	`408`
`409`		`- while((node = node.next()) != null) {`
	`409`	`+ while((node = node.nextPlain()) != null) {`
`410`	`410`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`411`		`- return node.reference().valueExists();`
	`411`	`+ return node.referencePlain().valueExists();`
`412`	`412`	`}`
`413`	`413`	`}`
`414`	`414`	`}`
`@@ -457,12 +457,12 @@ public boolean containsKey(final Object key) {`
`457`	`457`	`K nodeKey;`
`458`	`458`	`if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {`
`459`	`459`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`460`		`- return node.reference().value();`
	`460`	`+ return node.referencePlain().value();`
`461`	`461`	`}`
`462`	`462`
`463`		`- while((node = node.next()) != null) {`
	`463`	`+ while((node = node.nextPlain()) != null) {`
`464`	`464`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`465`		`- return node.reference().value();`
	`465`	`+ return node.referencePlain().value();`
`466`	`466`	`}`
`467`	`467`	`}`
`468`	`468`	`}`
`@@ -512,12 +512,12 @@ public V getOrDefault(final Object key, final V defaultValue) {`
`512`	`512`
`513`	`513`	`if(length > 0 && (node = SyncMap.getNode(table, (length - 1) & hash)) != null) {`
`514`	`514`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`515`		`- return node.reference().valueOr(defaultValue);`
	`515`	`+ return node.referencePlain().valueOr(defaultValue);`
`516`	`516`	`}`
`517`	`517`
`518`		`- while((node = node.next()) != null) {`
	`518`	`+ while((node = node.nextPlain()) != null) {`
`519`	`519`	`if(node.hash == hash && ((nodeKey = node.key) == key \|\| nodeKey.equals(key))) {`
`520`		`- return node.reference().valueOr(defaultValue);`
	`520`	`+ return node.referencePlain().valueOr(defaultValue);`
`521`	`521`	`}`
`522`	`522`	`}`
`523`	`523`	`}`
`@@ -1457,7 +1457,7 @@ public void forEach(final BiConsumer<? super K, ? super V> action) {`
`1457`	`1457`
`1458`	`1458`	`Node<K, V> node;`
`1459`	`1459`	`while((node = traverser.advanceNode()) != null) {`
`1460`		`- final Object current = node.reference().get();`
	`1460`	`+ final Object current = node.referencePlain().get();`
`1461`	`1461`	`if(current == null \|\| current == SyncMap.EXPUNGED) continue;`
`1462`	`1462`
`1463`	`1463`	`action.accept(node.key, (V) current);`
`@@ -1475,7 +1475,7 @@ public void clear() {`
`1475`	`1475`
`1476`	`1476`	`Node<K, V> node; long count = 0L;`
`1477`	`1477`	`while((node = traverser.advanceNode()) != null) {`
`1478`		`- final ObjectReference reference = node.reference();`
	`1478`	`+ final ObjectReference reference = node.referencePlain();`
`1479`	`1479`	`Object current = reference.get();`
`1480`	`1480`	`for(; ; ) {`
`1481`	`1481`	`if(current == null \|\| current == SyncMap.EXPUNGED) continue;`
`@@ -2450,7 +2450,7 @@ private void advanceEntry() {`
`2450`	`2450`
`2451`	`2451`	`Node<K, V> node;`
`2452`	`2452`	`while((node = this.advanceNode()) != null) {`
`2453`		`- final Object current = node.reference().get();`
	`2453`	`+ final Object current = node.referencePlain().get();`
`2454`	`2454`	`if(current == null \|\| current == SyncMap.EXPUNGED) continue;`
`2455`	`2455`
`2456`	`2456`	`this.next = new MapEntry(node.key, (V) current);`
`@@ -2479,7 +2479,7 @@ private void advanceEntry() {`
`2479`	`2479`	`/* package */ final @Nullable Node<K, V> advanceNode() {`
`2480`	`2480`	`Node<K, V> node;`
`2481`	`2481`	`if((node = this.next) != null) {`
`2482`		`- node = node.next();`
	`2482`	`+ node = node.nextPlain();`
`2483`	`2483`	`}`
`2484`	`2484`
`2485`	`2485`	`for(; ; ) {`