🐙 ready to test

Author: wolfram77

.gitignore

@@ -0,0 +1,65 @@
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# =========================
+# Operating System Files
+# =========================
+
+# OSX
+# =========================
+
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+/build/
+/dist/

BackoffLock.java

@@ -0,0 +1,99 @@
+import java.util.concurrent.*;
+import java.util.concurrent.locks.*;
+import java.util.concurrent.atomic.*;
+
+// Exponential Backoff Lock uses an atomic value for
+// indicating that some thread has engaged the lock
+// and is executing its critical section (CS).
+// 
+// Each thread that wants to enter CS waits until
+// the atomic lock is disengaged. Then it tries
+// to reengage it, but as several threads might
+// be trying the same, it may or may not succeed.
+// So it checks if it succeeded (with the same
+// atomic operation), and if so it done. If not
+// it backsoff for a random interval which is
+// doubled every retry (hence exponential), and
+// retries it all over again.
+// 
+// Once the thread is done with CS, it simply
+// disengages the lock.
+// 
+// As all thread wait (spin) for the lock to
+// disengage at the same time, but backoff if
+// they fail in reengaging the lock, contention
+// is reduced. However, this does not provide
+// first-come-first-served fairness. But, as
+// it only uses a single atomic value per lock
+// it is suitable for medium-contention
+// memory-limited architectures.
+
+class BackoffLock implements Lock {
+  AtomicBoolean locked;
+  static final long MIN_WAIT = 1;
+  static final long MAX_WAIT = 100;
+  // queue: indicates who has the token
+  // size:  max allowed threads (size of queue)
+  // tail:  points to end of queue
+  // slot:  points where each thread stands in queue
+
+  public BackoffLock() {
+    locked = new AtomicBoolean(false);
+  }
+
+  // 1. When thread wants to access critical
+  //    section, it checks to see if lock is already
+  //    engaged, and if so, waits (spins).
+  // 2. Once lock is disengaged it tries to reengage
+  //    it. So do all other threads wanting to enter
+  //    CS. Its a race between threads. So this
+  //    thread checks to see it was the one who was
+  //    successful, and if so its done.
+  // 3. If not, then it backsoff (sleeps) for a
+  //    random interval, and then retries again.
+  //    Each retry the range of backoff interval
+  //    is increased so reduce high-contention.
+  @Override
+  public void lock() {
+    long W = MIN_WAIT;
+    while(true) {                         // 1
+      while(locked.get()) Thread.yield(); // 1
+      if(!locked.getAndSet(true)) return; // 2
+      long w = (long) (Math.random() *   // 3
+        (MAX_WAIT-MIN_WAIT) + MIN_WAIT); // 3
+      W = Math.min(2*W, MAX_WAIT);       // 3
+      try { Thread.sleep(w); }           // 3
+      catch(InterruptedException e) {}   // 3
+    }
+  }
+
+  // 1. When a thread is done with its critical
+  //    section, it simply sets the "locked" state
+  //    to false.
+  @Override
+  public void unlock() {
+    locked.set(false); // 1
+  }
+
+  @Override
+  public void lockInterruptibly() throws InterruptedException {
+    lock();
+  }
+
+  @Override
+  public boolean tryLock() {
+    lock();
+    return true;
+  }
+
+  @Override
+  public boolean tryLock(long arg0, TimeUnit arg1) throws InterruptedException {
+    lock();
+    return true;
+  }
+
+  @Override
+  public Condition newCondition() {
+    return null;
+  }
+}

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Subhajit Sahu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Main.java

@@ -1,5 +1,82 @@
 class Main {
+  static BackoffLock lock;
+  static double[] sharedData;
+  static int SD = 100, CS = 100, TH = 10;
+  // SD: shared data srray size
+  // CS: critical section executed per thread
+  // TH: number of threads
+
+  // Critical section updated shared data
+  // with a random value. If all values
+  // dont match then it was not executed
+  // atomically!
+  static void criticalSection() {
+    try {
+    double v = Math.random();
+    for(int i=0; i<SD; i++) {
+      if(i % (SD/4)==0) Thread.sleep(1);
+      sharedData[i] = v + v*sharedData[i];
+    }
+    }
+    catch(InterruptedException e) {}
+  }
+
+  // Checks to see if all values match. If not,
+  // then critical section was not executed
+  // atomically.
+  static boolean criticalSectionWasAtomic() {
+    double v = sharedData[0];
+    for(int i=0; i<SD; i++)
+      if(sharedData[i]!=v) return false;
+    return true;
+  }
+
+  // Unsafe thread executes CS N times, without
+  // holding a lock. This can cause CS to be
+  // executed non-atomically which can be detected.
+  //
+  // Safe thread executes CS N times, while
+  // holding a lock. This allows CS to always be
+  // executed atomically which can be verified.
+  static Thread thread(int n, boolean safe) {
+    Thread t = new Thread(() -> {
+      for(int i=0; i<CS; i++) {
+        if(safe) lock.lock();
+        criticalSection();
+        if(safe) lock.unlock();
+      }
+      log(n+": done");
+    });
+    t.start();
+    return t;
+  }
+
+  // Tests to see if threads execute critical
+  // section atomically.
+  static void testThreads(boolean safe) {
+    String type = safe? "safe" : "unsafe";
+    log("Starting "+TH+" "+type+" threads ...");
+    Thread[] threads = new Thread[TH];
+    for(int i=0; i<TH; i++)
+      threads[i] = thread(i, safe);
+    try {
+    for(int i=0; i<TH; i++)
+      threads[i].join();
+    }
+    catch(InterruptedException e) {}
+    boolean atomic = criticalSectionWasAtomic();
+    log("Critical Section was atomic? "+atomic);
+    log("");
+  }
+
   public static void main(String[] args) {
-    System.out.println("Hello world!");
+    lock = new BackoffLock(TH);
+    sharedData = new double[SD];
+    testThreads(false);
+    testThreads(true);
+  }
+
+  static void log(String x) {
+    System.out.println(x);
   }
-}
+}

README.md

@@ -0,0 +1,66 @@
+Exponential Backoff Lock uses an atomic value for
+indicating that some thread has engaged the lock
+and is executing its critical section (CS).
+
+Each thread that wants to enter CS waits until
+the atomic lock is disengaged. Then it tries
+to reengage it, but as several threads might
+be trying the same, it may or may not succeed.
+So it checks if it succeeded (with the same
+atomic operation), and if so it done. If not
+it backsoff for a random interval which is
+doubled every retry (hence exponential), and
+retries it all over again.
+
+Once the thread is done with CS, it simply
+disengages the lock.
+
+As all thread wait (spin) for the lock to
+disengage at the same time, but backoff if
+they fail in reengaging the lock, contention
+is reduced. However, this does not provide
+first-come-first-served fairness. But, as
+it only uses a single atomic value per lock
+it is suitable for medium-contention
+memory-limited architectures.
+
+Exponential back off is a well-known technique
+used in Ethernet routing, presented in the
+context of multiprocessor mutual exclusion by
+[Anant Agarwal] and [Mathews Cherian].
+
+[Anant Agarwal]: https://scholar.google.com/citations?hl=en&user=E6XXUFcAAAAJ
+[Mathews Cherian]: https://dl.acm.org/profile/81100089786
+
+```java
+1. When thread wants to access critical
+   section, it checks to see if lock is already
+   engaged, and if so, waits (spins).
+2. Once lock is disengaged it tries to reengage
+   it. So do all other threads wanting to enter
+   CS. Its a race between threads. So this
+   thread checks to see it was the one who was
+   successful, and if so its done.
+3. If not, then it backsoff (sleeps) for a
+   random interval, and then retries again.
+   Each retry the range of backoff interval
+   is increased so reduce high-contention.
+```
+
+```java
+1. When a thread is done with its critical
+   section, it simply sets the "locked" state
+   to false.
+```
+
+See [BackoffLock.java] for code, [Main.java] for test, and [repl.it] for output.
+
+[BackoffLock.java]: https://repl.it/@wolfram77/backoff-lock#BackoffLock.java
+[Main.java]: https://repl.it/@wolfram77/backoff-lock#Main.java
+[repl.it]: https://backoff-lock.wolfram77.repl.run
+
+
+### references
+
+- [The Art of Multiprocessor Programming :: Maurice Herlihy, Nir Shavit](https://dl.acm.org/doi/book/10.5555/2385452)
+- [Adaptive backoff synchronization techniques :: Anant Agarwal, Mathews Cherian](https://ieeexplore.ieee.org/document/714578)