First REAL working of STM, *fast enough*

src/concurrency/stm/GlobalContext.java

@@ -8,7 +8,6 @@
  */
 public final class GlobalContext extends Context {
     private static GlobalContext instance = new GlobalContext();
-    private HashMap<Ref, Object> world = new HashMap<>();
 
     private GlobalContext() { }
 
@@ -18,20 +17,6 @@ public static GlobalContext get() {
 
     @Override
     <T> T get(Ref<T> ref) {
-        return (T)world.get(ref);
-    }
-
-    public void fillSnapshot(final HashMap<Ref, Object> inTxMap,
-                             final HashMap<Ref, Long> version) {
-        synchronized (STM.snapshotLock) {
-            for (Map.Entry<Ref, Object> refEntry : world.entrySet()) {
-                inTxMap.put(refEntry.getKey(), refEntry.getValue());
-                version.put(refEntry.getKey(), refEntry.getKey().revision);
-            }
-        }
-    }
-
-    public <T> void register(Ref<T> ref, T value) {
-        world.put(ref, value);
+        return ref.content.value;
     }
 }

src/concurrency/stm/Ref.java

@@ -4,12 +4,10 @@
  * @author mishadoff
  */
 public final class Ref<T> {
-    T value;
-    long revision = 0;
+    RefTuple<T, Long> content;
 
     public Ref(T value) {
-        this.value = value;
-        GlobalContext.get().register(this, value);
+        content = RefTuple.get(value, 0);
     }
 
     public T getValue(Context ctx) {

src/concurrency/stm/RefTuple.java

@@ -0,0 +1,18 @@
+package concurrency.stm;
+
+/**
+ * @author mishadoff
+ */
+public class RefTuple<V, R> {
+    V value;
+    R revision;
+
+    public RefTuple(V v, R r) {
+        this.value = v;
+        this.revision = r;
+    }
+
+    static <V, R>  RefTuple get(V v, R r) {
+        return new RefTuple<V, R>(v, r);
+    }
+}

src/concurrency/stm/STM.java

@@ -6,8 +6,7 @@
 public final class STM {
     private STM() {}
 
-    public static Object snapshotLock = new Object();
-    public static Object commitLock = new Object();
+    public static final Object commitLock = new Object();
 
     public static void transaction(TransactionBlock block) {
         boolean committed = false;

src/concurrency/stm/Transaction.java

@@ -3,6 +3,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
@@ -18,19 +19,25 @@ public final class Transaction extends Context{
 
     Transaction() {
         revision = transactionNum.incrementAndGet();
-        GlobalContext.get().fillSnapshot(inTxMap, version);
     }
 
     @Override
     <T> T get(Ref<T> ref) {
+        if (!inTxMap.containsKey(ref)) {
+            RefTuple<T, Long> tuple = ref.content;
+            inTxMap.put(ref, tuple.value);
+            if (!version.containsKey(ref)) {
+                version.put(ref, tuple.revision);
+            }
+        }
         return (T)inTxMap.get(ref);
     }
 
     <T> void set(Ref<T> ref, T value) {
         inTxMap.put(ref, value);
         toUpdate.add(ref);
         if (!version.containsKey(ref)) {
-            version.put(ref, ref.revision);
+            version.put(ref, ref.content.revision);
         }
     }
 
@@ -39,7 +46,7 @@ boolean commit() {
             // validation
             boolean isValid = true;
             for (Ref ref : inTxMap.keySet()) {
-                if (ref.revision != version.get(ref)) {
+                if (ref.content.revision != version.get(ref)) {
                     isValid = false;
                     break;
                 }
@@ -48,8 +55,7 @@ boolean commit() {
             // writes
             if (isValid) {
                 for (Ref ref : toUpdate) {
-                    ref.value = inTxMap.get(ref);
-                    ref.revision = revision;
+                    ref.content = RefTuple.get(inTxMap.get(ref), revision);
                 }
             }
             return isValid;

src/concurrency/test/Bank.java

@@ -15,7 +15,7 @@ public Bank() {
         randomFill();
     }
 
-    void transfer(Account a1, Account a2, int amount) {
+    synchronized void transfer(Account a1, Account a2, int amount) {
         a1.add(-amount);
         a2.add(amount);
     }
@@ -34,10 +34,10 @@ public void run() {
     }
 
     private void randomFill() {
-        int NUM = 10;
+        int NUM = 100;
         accounts = new Account[NUM];
         for (int i = 0; i < NUM; i++) {
-            accounts[i] = new Account(1000000);
+            accounts[i] = new Account(10000);
         }
     }
 
@@ -50,6 +50,12 @@ public int getRandomValue() {
     }
 
     public long sum() {
+        long sum = 0;
+        for (Account a : accounts) sum += a.getMoney();
+        return sum;
+    }
+
+    public long sumSTM() {
         long sum = 0;
         for (Account a : accounts) sum += a.getRef().getValue(GlobalContext.get());
         return sum;

src/concurrency/test/RefTest.java

@@ -12,7 +12,7 @@ public static void main(String[] args) {
 
         Bank bank = new Bank();
 
-        bank.transferSTM(a, a, 10);
+        bank.transferSTM(a, b, 10);
 
         System.out.println("A: " + a.getRef().getValue(GlobalContext.get()));
         System.out.println("B: " + b.getRef().getValue(GlobalContext.get()));

src/concurrency/test/Runner.java

@@ -3,8 +3,11 @@
 public class Runner {
     public static void main(String[] args) throws Exception{
         Bank bank = new Bank();
-        System.out.println("Bank sum before: " + bank.sum());
-        bank.simulate(100, 100000);
-        System.out.println("Bank sum after: " + bank.sum());
+        System.out.println("Bank sum before: " + bank.sumSTM());
+        long before = System.currentTimeMillis();
+        bank.simulate(10, 100000);
+        long after = System.currentTimeMillis();
+        System.out.println("Bank sum after: " + bank.sumSTM());
+        System.out.println("Elapsed time: " + (after - before));
     }
 }