switched to UUIDs for Ref ids

2 files changed, 32 insertions, 21 deletions

diff --git a/src/jvm/clojure/lang/LockingTransaction.java b/src/jvm/clojure/lang/LockingTransaction.java
index 8ee7678d..5a20109d 100644
--- a/src/jvm/clojure/lang/LockingTransaction.java
+++ b/src/jvm/clojure/lang/LockingTransaction.java
@@ -461,8 +461,8 @@ public static void main(String[] args){
 				si = (ArrayList<Ref>) items.clone();
 				}
 			Collections.shuffle(si);
-			tasks.add(new Incrementer(niters, si));
-			//tasks.add(new Commuter(niters, si));
+			//tasks.add(new Incrementer(niters, si));
+			tasks.add(new Commuter(niters, si));
 			}
 		ExecutorService e = Executors.newFixedThreadPool(nthreads);
 
diff --git a/src/jvm/clojure/lang/Ref.java b/src/jvm/clojure/lang/Ref.java
index 6e2e3351..8cdee3f6 100644
--- a/src/jvm/clojure/lang/Ref.java
+++ b/src/jvm/clojure/lang/Ref.java
@@ -12,18 +12,14 @@
 
 package clojure.lang;
 
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.UUID;
 
 public class Ref implements IFn, Comparable<Ref>{
 
 public int compareTo(Ref o){
-	if(o.id == id)
-		return 0;
-	if(o.id > id)
-		return -1;
-	return 1;
+	return uuid.compareTo(o.uuid);
 }
 
 public static class TVal{
@@ -54,24 +50,22 @@ public static class TVal{
 }
 
 
-final static AtomicLong ids = new AtomicLong();
-
 TVal tvals;
 final AtomicInteger faults;
 transient volatile InheritableThreadLocal<Binding> dvals;
 final ReentrantReadWriteLock lock;
 LockingTransaction.Info tinfo;
-final long id;
-transient volatile Object cached;
+final UUID uuid;
+transient volatile Object cacheVal;
 
 public Ref(){
 	this.tvals = null;
 	this.dvals = null;
 	this.tinfo = null;
-	faults = new AtomicInteger();
-	this.cached = faults;  //use faults as magic never-been-set value
-	lock = new ReentrantReadWriteLock();
-	id = ids.getAndIncrement();
+	this.faults = new AtomicInteger();
+	this.lock = new ReentrantReadWriteLock();
+	this.cacheVal = lock;  //use lock as magic never-been-set value
+	this.uuid = UUID.randomUUID();
 }
 
 public Ref(Object initVal){
@@ -79,6 +73,23 @@ public Ref(Object initVal){
 	tvals = new TVal(initVal, 0, System.currentTimeMillis());
 }
 
+//note - makes no attempt to ensure there is no other Ref with same UUID
+
+//use only with a cache/registry
+public Ref(UUID uuid, Object initVal){
+	tvals = new TVal(initVal, 0, System.currentTimeMillis());
+	this.dvals = null;
+	this.tinfo = null;
+	this.faults = new AtomicInteger();
+	this.lock = new ReentrantReadWriteLock();
+	this.cacheVal = lock;  //use lock as magic never-been-set value
+	this.uuid = uuid;
+}
+
+public UUID getUUID(){
+	return uuid;
+}
+
 //not necessarily the latest val
 
 // ok out of transaction
@@ -86,13 +97,13 @@ public Object cachedVal(){
 	Binding b = getThreadBinding();
 	if(b != null)
 		return b.val;
-	if(cached != faults)
-		return cached;
+	if(cacheVal != lock)
+		return cacheVal;
 	try
 		{
 		lock.readLock().lock();
 		if(tvals != null)
-			return cached = tvals.val;
+			return cacheVal = tvals.val;
 		throw new IllegalStateException(this.toString() + " is unbound.");
 		}
 	finally
@@ -112,7 +123,7 @@ public Object currentVal(){
 		{
 		lock.readLock().lock();
 		if(tvals != null)
-			return cached = tvals.val;
+			return cacheVal = tvals.val;
 		throw new IllegalStateException(this.toString() + " is unbound.");
 		}
 	finally
@@ -154,7 +165,7 @@ public Object get() throws Exception{
 	Binding b = getThreadBinding();
 	if(b != null)
 		return b.val;
-	return cached = LockingTransaction.getEx().doGet(this);
+	return cacheVal = LockingTransaction.getEx().doGet(this);
 }
 
 public Object set(Object val) throws Exception{