Add the ability to bind groups of threads by sockets or by core.

peter-lawrey · peter-lawrey · commit 8deae2e4982b · 2012-01-12T15:02:33.000Z
diff --git a/README b/README
@@ -1,5 +1,7 @@
 [ Version History ]
 
+Version 1.3 - Support thread layout strategies for using the same/different socket or cores.
+
 Version 1.2.2 - Improve logging and handling of edge cases
 
 Version 1.2.1 - Fix a critical bug and added a unit test.
diff --git a/src/main/java/vanilla/java/affinity/AffinityLock.java b/src/main/java/vanilla/java/affinity/AffinityLock.java
@@ -75,12 +75,12 @@ public static AffinityLock acquireLock() {
     }
 
     public static AffinityLock acquireLock(boolean bind) {
-        return acquireLock(bind, 0, AffinityAssignmentStrategies.ANY);
+        return acquireLock(bind, 0, AffinityStrategies.ANY);
     }
 
-    private static AffinityLock acquireLock(boolean bind, int cpuId, AffinityAssignmentStrategy... strategies) {
+    private static AffinityLock acquireLock(boolean bind, int cpuId, AffinityStrategy... strategies) {
         synchronized (AffinityLock.class) {
-            for (AffinityAssignmentStrategy strategy : strategies) {
+            for (AffinityStrategy strategy : strategies) {
                 for (int i = PROCESSORS - 1; i > 0; i--) {
                     AffinityLock al = LOCKS[i];
                     if (al.canReserve() && strategy.matches(cpuId, i)) {
@@ -155,7 +155,7 @@ private boolean canReserve() {
         return true;
     }
 
-    public AffinityLock acquireLock(AffinityAssignmentStrategy... strategies) {
+    public AffinityLock acquireLock(AffinityStrategy... strategies) {
         return acquireLock(false, id, strategies);
     }
 
diff --git a/src/main/java/vanilla/java/affinity/AffinityStrategies.java b/src/main/java/vanilla/java/affinity/AffinityStrategies.java
@@ -3,7 +3,7 @@
 /**
  * @author peter.lawrey
  */
-public enum AffinityAssignmentStrategies implements AffinityAssignmentStrategy {
+public enum AffinityStrategies implements AffinityStrategy {
     ANY {
         @Override
         public boolean matches(int cpuId, int cpuId2) {
diff --git a/src/main/java/vanilla/java/affinity/AffinityStrategy.java b/src/main/java/vanilla/java/affinity/AffinityStrategy.java
@@ -3,7 +3,7 @@
 /**
  * @author peter.lawrey
  */
-public interface AffinityAssignmentStrategy {
+public interface AffinityStrategy {
     /**
      * @param cpuId  to cpudId to compare
      * @param cpuId2 with a second cpuId
diff --git a/src/test/java/vanilla/java/affinity/AffinityLockBindMain.java b/src/test/java/vanilla/java/affinity/AffinityLockBindMain.java
@@ -16,6 +16,8 @@
 
 package vanilla.java.affinity;
 
+import static vanilla.java.affinity.AffinityStrategies.*;
+
 /**
  * @author peter.lawrey
  */
@@ -24,16 +26,16 @@ public static void main(String... args) throws InterruptedException {
         AffinityLock al = AffinityLock.acquireLock();
         try {
             // find a cpu on a different socket, otherwise a different core.
-            AffinityLock readerLock = al.acquireLock(AffinityAssignmentStrategies.DIFFERENT_SOCKET, AffinityAssignmentStrategies.DIFFERENT_CORE);
+            AffinityLock readerLock = al.acquireLock(DIFFERENT_SOCKET, DIFFERENT_CORE);
             new Thread(new SleepRunnable(readerLock), "reader").start();
             // find a cpu on the same core, or the same socket, or any free cpu.
-            AffinityLock writerLock = readerLock.acquireLock(AffinityAssignmentStrategies.SAME_CORE, AffinityAssignmentStrategies.SAME_SOCKET, AffinityAssignmentStrategies.ANY);
+            AffinityLock writerLock = readerLock.acquireLock(SAME_CORE, SAME_SOCKET, ANY);
             new Thread(new SleepRunnable(writerLock), "writer").start();
             Thread.sleep(200);
         } finally {
             al.release();
         }
-        // re-use the same cpu for the engine.
+// re-use the same cpu for the engine.
         new Thread(new SleepRunnable(al), "engine").start();
 
         Thread.sleep(200);

Original file line number	Diff line number	Diff line change
`@@ -75,12 +75,12 @@ public static AffinityLock acquireLock() {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`public static AffinityLock acquireLock(boolean bind) {`
`78`		`- return acquireLock(bind, 0, AffinityAssignmentStrategies.ANY);`
	`78`	`+ return acquireLock(bind, 0, AffinityStrategies.ANY);`
`79`	`79`	`}`
`80`	`80`
`81`		`- private static AffinityLock acquireLock(boolean bind, int cpuId, AffinityAssignmentStrategy... strategies) {`
	`81`	`+ private static AffinityLock acquireLock(boolean bind, int cpuId, AffinityStrategy... strategies) {`
`82`	`82`	`synchronized (AffinityLock.class) {`
`83`		`- for (AffinityAssignmentStrategy strategy : strategies) {`
	`83`	`+ for (AffinityStrategy strategy : strategies) {`
`84`	`84`	`for (int i = PROCESSORS - 1; i > 0; i--) {`
`85`	`85`	`AffinityLock al = LOCKS[i];`
`86`	`86`	`if (al.canReserve() && strategy.matches(cpuId, i)) {`
`@@ -155,7 +155,7 @@ private boolean canReserve() {`
`155`	`155`	`return true;`
`156`	`156`	`}`
`157`	`157`
`158`		`- public AffinityLock acquireLock(AffinityAssignmentStrategy... strategies) {`
	`158`	`+ public AffinityLock acquireLock(AffinityStrategy... strategies) {`
`159`	`159`	`return acquireLock(false, id, strategies);`
`160`	`160`	`}`
`161`	`161`