From 389545dd767eb9ed15abacc604016c6da4159e62 Mon Sep 17 00:00:00 2001
From: "yevgen.pavlenko" <yevgen.pavlenko@chronicle.software>
Date: Tue, 9 Apr 2024 17:25:10 +0300
Subject: [PATCH 01/53] Make "make-c" profile active on Linux only.

---
 affinity/pom.xml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/affinity/pom.xml b/affinity/pom.xml
index d63ec73fa..d41ec4de7 100644
--- a/affinity/pom.xml
+++ b/affinity/pom.xml
@@ -110,6 +110,10 @@
         <profile>
             <id>make-c</id>
             <activation>
+                <os>
+                    <family>linux</family>
+                    <arch>!arm</arch>
+                </os>
                 <property>
                     <name>!dontMake</name>
                 </property>

From acdd01cf7bcc602a4190992ab79ffe70dbfa442d Mon Sep 17 00:00:00 2001
From: "yevgen.pavlenko" <yevgen.pavlenko@chronicle.software>
Date: Tue, 9 Apr 2024 14:22:38 +0300
Subject: [PATCH 02/53] Modify warning logic in WindowsJNAAffinity.setAffinity

---
 .../main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
index 2c0fc2d7c..071e95d59 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
@@ -89,7 +89,7 @@ public void setAffinity(final BitSet affinity) {
             throw new IllegalStateException("SetThreadAffinityMask((" + pid + ") , &(" + affinity + ") ) errorNo=" + e.getErrorCode(), e);
         }
         BitSet affinity2 = getAffinity0();
-        if (!affinity2.equals(affinity)) {
+        if (!affinity2.intersects(affinity)) {
             LoggerFactory.getLogger(WindowsJNAAffinity.class).warn("Tried to set affinity to " + affinity + " but was " + affinity2 + " you may have insufficient access rights");
         }
         currentAffinity.set((BitSet) affinity.clone());

From b4bca59817cc05de53667872c953e463173efe2c Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:19:51 +0100
Subject: [PATCH 03/53] Update copyright year to 2025 across multiple files

---
 LICENSE                                       |  2 +-
 affinity-test/pom.xml                         |  2 +-
 .../affinity/osgi/OSGiPlaceholder.java        |  2 +-
 .../openhft/affinity/osgi/OSGiBundleTest.java |  2 +-
 .../openhft/affinity/osgi/OSGiTestBase.java   |  2 +-
 affinity/pom.xml                              |  2 +-
 .../c/net_openhft_ticker_impl_JNIClock.cpp    |  2 +-
 ...terprise_internals_impl_NativeAffinity.cpp |  2 +-
 ...ise_internals_impl_NativeAffinity_MacOSX.c |  2 +-
 .../java/net/openhft/affinity/Affinity.java   |  7 ++---
 .../net/openhft/affinity/AffinityLock.java    | 28 +++++++++----------
 .../openhft/affinity/AffinityStrategies.java  |  2 +-
 .../openhft/affinity/AffinityStrategy.java    |  2 +-
 .../affinity/AffinityThreadFactory.java       |  2 +-
 .../net/openhft/affinity/BootClassPath.java   |  2 +-
 .../java/net/openhft/affinity/CpuLayout.java  |  2 +-
 .../java/net/openhft/affinity/IAffinity.java  |  2 +-
 .../java/net/openhft/affinity/LockCheck.java  |  2 +-
 .../net/openhft/affinity/LockInventory.java   | 10 +++----
 .../openhft/affinity/MicroJitterSampler.java  | 18 ++++++------
 .../openhft/affinity/impl/LinuxHelper.java    |  8 +++---
 .../affinity/impl/LinuxJNAAffinity.java       |  2 +-
 .../openhft/affinity/impl/NoCpuLayout.java    |  2 +-
 .../openhft/affinity/impl/NullAffinity.java   |  2 +-
 .../openhft/affinity/impl/OSXJNAAffinity.java |  2 +-
 .../affinity/impl/PosixJNAAffinity.java       |  2 +-
 .../affinity/impl/SolarisJNAAffinity.java     |  2 +-
 .../net/openhft/affinity/impl/Utilities.java  |  2 +-
 .../affinity/impl/VanillaCpuLayout.java       |  2 +-
 .../openhft/affinity/impl/VersionHelper.java  |  2 +-
 .../affinity/impl/WindowsJNAAffinity.java     |  2 +-
 .../lockchecker/FileLockBasedLockChecker.java |  4 +--
 .../affinity/lockchecker/LockChecker.java     |  4 +--
 .../affinity/lockchecker/LockReference.java   |  4 +--
 .../affinity/main/AffinityTestMain.java       |  4 +--
 .../main/java/net/openhft/ticker/ITicker.java |  2 +-
 .../main/java/net/openhft/ticker/Ticker.java  |  2 +-
 .../net/openhft/ticker/impl/JNIClock.java     |  2 +-
 .../net/openhft/ticker/impl/SystemClock.java  |  2 +-
 .../internals/impl/NativeAffinity.java        |  2 +-
 .../affinity/AffinityLockBindMain.java        |  2 +-
 .../openhft/affinity/AffinityLockMain.java    |  2 +-
 .../openhft/affinity/AffinityLockTest.java    |  2 +-
 .../openhft/affinity/AffinitySupportMain.java |  2 +-
 .../affinity/AffinityThreadFactoryMain.java   |  2 +-
 .../openhft/affinity/BaseAffinityTest.java    |  4 +--
 .../openhft/affinity/BootClassPathTest.java   |  4 +--
 .../affinity/FileLockLockCheckTest.java       |  2 +-
 .../openhft/affinity/InterrupedThread.java    |  2 +-
 .../net/openhft/affinity/LockCheckTest.java   |  2 +-
 .../affinity/MultiProcessAffinityTest.java    |  4 +--
 .../impl/AbstractAffinityImplTest.java        |  2 +-
 .../affinity/impl/LinuxJNAAffinityTest.java   |  2 +-
 .../affinity/impl/NativeAffinityImpTest.java  |  2 +-
 .../affinity/impl/PosixJNAAffinityTest.java   |  2 +-
 .../affinity/impl/VanillaCpuLayoutTest.java   |  2 +-
 .../affinity/impl/VersionHelperTest.java      |  2 +-
 .../TestFileLockBasedLockChecker.java         |  4 +--
 .../net/openhft/ticker/impl/JNIClockTest.java |  2 +-
 .../enterprise/internals/JnaAffinityTest.java |  2 +-
 .../internals/NativeAffinityTest.java         |  2 +-
 affinity/src/test/resources/i7.properties     |  2 +-
 pom.xml                                       |  2 +-
 63 files changed, 91 insertions(+), 112 deletions(-)

diff --git a/LICENSE b/LICENSE
index a1993e4de..f7f8b7f7d 100644
--- a/LICENSE
+++ b/LICENSE
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2014-2018 Chronicle Software Ltd
+   Copyright 2014-2025 chronicle.software
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/affinity-test/pom.xml b/affinity-test/pom.xml
index 97b6857dc..e90b2d811 100644
--- a/affinity-test/pom.xml
+++ b/affinity-test/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2016 chronicle.software
+  ~ Copyright 2016-2025 chronicle.software
   ~
   ~ Licensed under the *Apache License, Version 2.0* (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/affinity-test/src/main/java/net/openhft/affinity/osgi/OSGiPlaceholder.java b/affinity-test/src/main/java/net/openhft/affinity/osgi/OSGiPlaceholder.java
index becba5df0..bd9b2d0a3 100644
--- a/affinity-test/src/main/java/net/openhft/affinity/osgi/OSGiPlaceholder.java
+++ b/affinity-test/src/main/java/net/openhft/affinity/osgi/OSGiPlaceholder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
index 727ea8c28..9d1cfee02 100644
--- a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
+++ b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
index 3dc8d2652..b50b0a8ce 100644
--- a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
+++ b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/pom.xml b/affinity/pom.xml
index 6e84f2418..1dc132f9f 100644
--- a/affinity/pom.xml
+++ b/affinity/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2016 chronicle.software
+  ~ Copyright 2016-2025 chronicle.software
   ~
   ~ Licensed under the *Apache License, Version 2.0* (the "License");
   ~ you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/c/net_openhft_ticker_impl_JNIClock.cpp b/affinity/src/main/c/net_openhft_ticker_impl_JNIClock.cpp
index d5534c073..e68c32036 100644
--- a/affinity/src/main/c/net_openhft_ticker_impl_JNIClock.cpp
+++ b/affinity/src/main/c/net_openhft_ticker_impl_JNIClock.cpp
@@ -1,5 +1,5 @@
 /* vim: syntax=cpp
- * Copyright 2015 Higher Frequency Trading
+ * Copyright 2015-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity.cpp b/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity.cpp
index 013b85433..721f1e7f3 100644
--- a/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity.cpp
+++ b/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity.cpp
@@ -1,5 +1,5 @@
 /* vim: syntax=cpp
- * Copyright 2011 Higher Frequency Trading
+ * Copyright 2011-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c b/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c
index a2d4666ce..f0f2fdc09 100644
--- a/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c
+++ b/affinity/src/main/c/software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 Peter Lawrey & Jerry Shea
+ * Copyright 2011-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/Affinity.java b/affinity/src/main/java/net/openhft/affinity/Affinity.java
index 89f049621..d4654749a 100644
--- a/affinity/src/main/java/net/openhft/affinity/Affinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/Affinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -190,11 +190,10 @@ public static void setThreadId() {
     public static boolean isJNAAvailable() {
         if (JNAAvailable == null) {
             int majorVersion = Integer.parseInt(Native.VERSION.split("\\.")[0]);
-            if(majorVersion < 5) {
+            if (majorVersion < 5) {
                 LOGGER.warn("Affinity library requires JNA version >= 5");
                 JNAAvailable = false;
-            }
-            else {
+            } else {
                 try {
                     Class.forName("com.sun.jna.Platform");
                     JNAAvailable = true;
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index f7a01619d..be4b6536e 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -131,7 +131,7 @@ private static BitSet getReservedAffinity0() {
         reservedAffinity = reservedAffinity.trim();
         long[] longs = new long[1 + (reservedAffinity.length() - 1) / 16];
         int end = reservedAffinity.length();
-        for(int i = 0; i < longs.length ; i++) {
+        for (int i = 0; i < longs.length; i++) {
             int begin = Math.max(0, end - 16);
             longs[i] = Long.parseLong(reservedAffinity.substring(begin, end), 16);
             end = begin;
@@ -148,14 +148,6 @@ public static AffinityLock acquireLock() {
         return acquireLock(true);
     }
 
-    static class Warnings {
-        static void warmNoReservedCPUs() {
-            if (RESERVED_AFFINITY.isEmpty() && PROCESSORS > 1) {
-                LoggerFactory.getLogger(AffinityLock.class).info("No isolated CPUs found, so assuming CPUs 1 to {} available.", (PROCESSORS - 1));
-            }
-        }
-    }
-
     /**
      * Assign any free core to this thread. <p> In reality, only one cpu is assigned, the rest of
      * the threads for that core are reservable so they are not used.
@@ -199,11 +191,9 @@ public static AffinityLock acquireLock(int cpuId) {
      * @return A handle for an affinity lock, or nolock if no available CPU in the array
      */
     public static AffinityLock acquireLock(int[] cpus) {
-        for( int cpu : cpus )
-        {
+        for (int cpu : cpus) {
             AffinityLock lock = tryAcquireLock(true, cpu);
-            if(lock != null)
-            {
+            if (lock != null) {
                 LOGGER.info("Acquired lock on CPU {}", cpu);
                 return lock;
             }
@@ -309,7 +299,7 @@ private static AffinityLock acquireLock(boolean bind, int cpuId, @NotNull Affini
      * Try to acquire a lock on the specified core
      * Returns lock if successful, or null if cpu cannot be acquired
      *
-     * @param bind - if true, bind the current thread; if false, reserve a cpu which can be bound later
+     * @param bind  - if true, bind the current thread; if false, reserve a cpu which can be bound later
      * @param cpuId - the cpu to lock
      * @return - A handle to an affinity lock on success; null if failed to lock
      */
@@ -490,4 +480,12 @@ else if (base)
             sb.append("CPU not available");
         return sb.toString();
     }
+
+    static class Warnings {
+        static void warmNoReservedCPUs() {
+            if (RESERVED_AFFINITY.isEmpty() && PROCESSORS > 1) {
+                LoggerFactory.getLogger(AffinityLock.class).info("No isolated CPUs found, so assuming CPUs 1 to {} available.", (PROCESSORS - 1));
+            }
+        }
+    }
 }
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityStrategies.java b/affinity/src/main/java/net/openhft/affinity/AffinityStrategies.java
index 9a0d3e279..b833eaa87 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityStrategies.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityStrategies.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityStrategy.java b/affinity/src/main/java/net/openhft/affinity/AffinityStrategy.java
index 0d8dc27bd..ccdc782f0 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityStrategy.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityStrategy.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java b/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
index 5962f4b62..91bd4d29b 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
index 392ea7df6..9dfa07f9d 100644
--- a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
+++ b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/CpuLayout.java b/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
index 92981330e..7221d7dfb 100644
--- a/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/IAffinity.java b/affinity/src/main/java/net/openhft/affinity/IAffinity.java
index f68598e08..d389c5afa 100644
--- a/affinity/src/main/java/net/openhft/affinity/IAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/IAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/LockCheck.java b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
index 29b962f07..259aaf40b 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockCheck.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/LockInventory.java b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
index 25714b1d1..fd94eb263 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockInventory.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -127,7 +127,7 @@ public final synchronized void set(CpuLayout cpuLayout) {
     private void shrink(NavigableMap<Integer, AffinityLock[]> physicalCoreLocks) {
         for (Map.Entry<Integer, AffinityLock[]> e : physicalCoreLocks.entrySet()) {
             final AffinityLock[] locks = e.getValue();
-            for (int i=0; i<locks.length; i++) {
+            for (int i = 0; i < locks.length; i++) {
                 if (locks[i] == null) {
                     final AffinityLock[] locks2 = new AffinityLock[i];
                     System.arraycopy(locks, 0, locks2, 0, i);
@@ -215,9 +215,9 @@ public final synchronized AffinityLock acquireCore(boolean bind, int cpuId, Affi
 
                 final AffinityLock al = als[0];
                 try {
-                if (updateLockForCurrentThread(bind, al, true)) {
-                    return al;
-                }
+                    if (updateLockForCurrentThread(bind, al, true)) {
+                        return al;
+                    }
                 } catch (ClosedByInterruptException e) {
                     Thread.currentThread().interrupt();
                     return noLock();
diff --git a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
index f9e34715d..3b5ebef95 100644
--- a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
+++ b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2014 Higher Frequency Trading
- *
- *       https://chronicle.software
+ * Copyright 2014-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -56,6 +54,13 @@ public static void main(String... ignored) throws InterruptedException {
         t.join();
     }
 
+    private static String asString(long timeNS) {
+        return timeNS < 1000 ? timeNS + "ns" :
+                timeNS < 1000000 ? timeNS / 1000 + "us" :
+                        timeNS < 1000000000 ? timeNS / 1000000 + "ms" :
+                                timeNS / 1000000000 + "sec";
+    }
+
     private void once() throws InterruptedException {
         if (UTIL >= 100) {
             sample(30L * 1000 * 1000 * 1000);
@@ -91,13 +96,6 @@ public void run() {
         }
     }
 
-    private static String asString(long timeNS) {
-        return timeNS < 1000 ? timeNS + "ns" :
-                timeNS < 1000000 ? timeNS / 1000 + "us" :
-                        timeNS < 1000000000 ? timeNS / 1000000 + "ms" :
-                                timeNS / 1000000000 + "sec";
-    }
-
     void reset() {
         for (int i = 0; i < DELAY.length; ++i)
             count[i] = 0;
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
index 448d37bd7..df5cbbc3d 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -66,9 +66,9 @@ cpu_set_t sched_getaffinity() {
         return cpuset;
     }
 
-	public static void sched_setaffinity(final BitSet affinity) {
-		sched_setaffinity(0, affinity);
-	}
+    public static void sched_setaffinity(final BitSet affinity) {
+        sched_setaffinity(0, affinity);
+    }
 
     public static void sched_setaffinity(final int pid, final BitSet affinity) {
         final CLibrary lib = CLibrary.INSTANCE;
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
index 5f93ca361..3ec4d2730 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java b/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
index aabbc9d0e..b22c36cf7 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
index b33504b3c..c0b32483e 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
index 39ed90d55..86eb05745 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
index 25e3053f0..261c23bfa 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
index a9c6b011b..b0c7e1436 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java b/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
index b81f9d919..676f1567f 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
index 55790d734..d3e9c89c1 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java b/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
index 98e1c19f0..5ad224302 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
index 2c0fc2d7c..27b3af156 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
index 6b596a49f..c13040e1d 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
index f0a02f6d5..8df4eafa1 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockReference.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockReference.java
index 419073fe6..82d89489d 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockReference.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockReference.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java b/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
index 6aa280014..01ec845b3 100644
--- a/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
+++ b/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/ticker/ITicker.java b/affinity/src/main/java/net/openhft/ticker/ITicker.java
index 70c3934df..5438e51d8 100644
--- a/affinity/src/main/java/net/openhft/ticker/ITicker.java
+++ b/affinity/src/main/java/net/openhft/ticker/ITicker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/ticker/Ticker.java b/affinity/src/main/java/net/openhft/ticker/Ticker.java
index 6e17c653c..596fe9f2b 100644
--- a/affinity/src/main/java/net/openhft/ticker/Ticker.java
+++ b/affinity/src/main/java/net/openhft/ticker/Ticker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java b/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
index 1808af9a7..b493d6020 100644
--- a/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
+++ b/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/net/openhft/ticker/impl/SystemClock.java b/affinity/src/main/java/net/openhft/ticker/impl/SystemClock.java
index 2c3402433..8c88c2aef 100644
--- a/affinity/src/main/java/net/openhft/ticker/impl/SystemClock.java
+++ b/affinity/src/main/java/net/openhft/ticker/impl/SystemClock.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/main/java/software/chronicle/enterprise/internals/impl/NativeAffinity.java b/affinity/src/main/java/software/chronicle/enterprise/internals/impl/NativeAffinity.java
index 5da995bcd..2071dd77e 100644
--- a/affinity/src/main/java/software/chronicle/enterprise/internals/impl/NativeAffinity.java
+++ b/affinity/src/main/java/software/chronicle/enterprise/internals/impl/NativeAffinity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockBindMain.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockBindMain.java
index 68ec39073..1935e105f 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockBindMain.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockBindMain.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockMain.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockMain.java
index 689eabda4..5f09608c9 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockMain.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockMain.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index dd286686f..f4d8bf76e 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinitySupportMain.java b/affinity/src/test/java/net/openhft/affinity/AffinitySupportMain.java
index 6841b3a65..9e0d8efc9 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinitySupportMain.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinitySupportMain.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
index 1b9fb99a2..9b7960e01 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/BaseAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/BaseAffinityTest.java
index 5bfeacf95..63f4f46af 100644
--- a/affinity/src/test/java/net/openhft/affinity/BaseAffinityTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/BaseAffinityTest.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java b/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
index 3c0c29df8..bf0cb8268 100644
--- a/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
index 1576851f4..82b64435a 100644
--- a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/InterrupedThread.java b/affinity/src/test/java/net/openhft/affinity/InterrupedThread.java
index 8ea9c47e2..92441d61a 100644
--- a/affinity/src/test/java/net/openhft/affinity/InterrupedThread.java
+++ b/affinity/src/test/java/net/openhft/affinity/InterrupedThread.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
index 11ec9463f..c7f04465b 100644
--- a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
index fc5678cf3..ed96007fb 100644
--- a/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java b/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
index f858e8086..02ed43383 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/LinuxJNAAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/impl/LinuxJNAAffinityTest.java
index 52ab34bfe..0a4e924e4 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/LinuxJNAAffinityTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/LinuxJNAAffinityTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/NativeAffinityImpTest.java b/affinity/src/test/java/net/openhft/affinity/impl/NativeAffinityImpTest.java
index 04c200e3f..4b807d7a2 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/NativeAffinityImpTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/NativeAffinityImpTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/PosixJNAAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/impl/PosixJNAAffinityTest.java
index d25aa89ae..e04c06610 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/PosixJNAAffinityTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/PosixJNAAffinityTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutTest.java b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutTest.java
index 581874871..73ceb7fee 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/VersionHelperTest.java b/affinity/src/test/java/net/openhft/affinity/impl/VersionHelperTest.java
index 232d12c3c..9521d5cb2 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/VersionHelperTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/VersionHelperTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 20127chronicle.software
+ * Copyright 2017-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/affinity/testimpl/TestFileLockBasedLockChecker.java b/affinity/src/test/java/net/openhft/affinity/testimpl/TestFileLockBasedLockChecker.java
index 68b3f3566..8e93c0f21 100644
--- a/affinity/src/test/java/net/openhft/affinity/testimpl/TestFileLockBasedLockChecker.java
+++ b/affinity/src/test/java/net/openhft/affinity/testimpl/TestFileLockBasedLockChecker.java
@@ -1,7 +1,5 @@
 /*
- * Copyright 2016-2022 chronicle.software
- *
- *       https://chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/net/openhft/ticker/impl/JNIClockTest.java b/affinity/src/test/java/net/openhft/ticker/impl/JNIClockTest.java
index b87b793fe..56335a56c 100644
--- a/affinity/src/test/java/net/openhft/ticker/impl/JNIClockTest.java
+++ b/affinity/src/test/java/net/openhft/ticker/impl/JNIClockTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java b/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
index d9a723019..db6fa69f4 100644
--- a/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
+++ b/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java b/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
index 61991595d..33de98652 100644
--- a/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
+++ b/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 chronicle.software
+ * Copyright 2016-2025 chronicle.software
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
diff --git a/affinity/src/test/resources/i7.properties b/affinity/src/test/resources/i7.properties
index 20191b55d..9e617cf9c 100644
--- a/affinity/src/test/resources/i7.properties
+++ b/affinity/src/test/resources/i7.properties
@@ -1,5 +1,5 @@
 #
-# Copyright 2016 higherfrequencytrading.com
+# Copyright 2016-2025 chronicle.software
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
diff --git a/pom.xml b/pom.xml
index d6bd9c4a0..9d328d8d4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright 2016 chronicle.software
+  ~ Copyright 2016-2025 chronicle.software
   ~
   ~ Licensed under the *Apache License, Version 2.0* (the "License");
   ~ you may not use this file except in compliance with the License.

From 72d5a15c8fffa6ed25b2f740a72866a290625dc1 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:31:28 +0100
Subject: [PATCH 04/53] Refactor assertions and logging for clarity and
 consistency

---
 .../openhft/affinity/osgi/OSGiBundleTest.java |  2 +-
 .../openhft/affinity/osgi/OSGiTestBase.java   |  2 +-
 .../net/openhft/affinity/AffinityLock.java    | 10 ++++++----
 .../affinity/AffinityThreadFactory.java       | 12 +++++-------
 .../net/openhft/affinity/BootClassPath.java   |  8 +++++---
 .../net/openhft/affinity/LockInventory.java   |  6 ++++--
 .../openhft/affinity/MicroJitterSampler.java  |  1 +
 .../openhft/affinity/impl/LinuxHelper.java    | 18 +++++++++---------
 .../affinity/impl/LinuxJNAAffinity.java       |  2 +-
 .../affinity/impl/PosixJNAAffinity.java       |  2 +-
 .../affinity/impl/VanillaCpuLayout.java       |  3 ++-
 .../openhft/affinity/impl/VersionHelper.java  |  4 ++--
 .../affinity/impl/WindowsJNAAffinity.java     |  3 ++-
 .../lockchecker/FileLockBasedLockChecker.java | 13 +++++++------
 .../affinity/main/AffinityTestMain.java       |  7 ++++---
 .../net/openhft/ticker/impl/JNIClock.java     |  5 +++--
 .../openhft/affinity/AffinityLockTest.java    | 14 +++++---------
 .../affinity/AffinityThreadFactoryMain.java   | 10 ++++------
 .../affinity/MultiProcessAffinityTest.java    | 19 +++++++++++--------
 .../impl/AbstractAffinityImplTest.java        |  8 ++------
 .../enterprise/internals/JnaAffinityTest.java | 11 +++--------
 .../internals/NativeAffinityTest.java         | 11 +++--------
 22 files changed, 82 insertions(+), 89 deletions(-)

diff --git a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
index 9d1cfee02..80949898f 100644
--- a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
+++ b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java
@@ -64,7 +64,7 @@ public void checkInject() {
     public void checkBundleState() {
         final Bundle bundle = findBundle(context, "net.openhft.affinity");
         assertNotNull(bundle);
-        assertEquals(bundle.getState(), Bundle.ACTIVE);
+        assertEquals(Bundle.ACTIVE, bundle.getState());
     }
 
     @Test
diff --git a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
index b50b0a8ce..a1e9fcc96 100644
--- a/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
+++ b/affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiTestBase.java
@@ -29,7 +29,7 @@ public class OSGiTestBase {
 
     public static Option workspaceBundle(String projectName) {
         String baseDir = System.getProperty("main.basedir");
-        String bundleDir = null;
+        String bundleDir;
 
         bundleDir = String.format("%s/%s/target/classes", baseDir, projectName);
         if (new File(bundleDir).exists()) {
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index be4b6536e..24696033c 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -199,7 +199,7 @@ public static AffinityLock acquireLock(int[] cpus) {
             }
         }
 
-        LOGGER.warn("Failed to lock any CPU in explicit list " + Arrays.toString(cpus));
+        LOGGER.warn("Failed to lock any CPU in explicit list {}", Arrays.toString(cpus));
         return LOCK_INVENTORY.noLock();
     }
 
@@ -218,7 +218,7 @@ public static AffinityLock acquireLockLastMinus(int n) {
      * <ul>
      *     <li>"N" being a positive integer means allocate this CPU,</li>
      *     <li>"last" or "last-N" means allocate from the end,</li>
-     *     <li>"csv:1,2,5,6 eg means allocate first free core from the provided</li>
+     *     <li>"csv:1,2,5,6" eg means allocate first free core from the provided</li>
      *     <li>"any" means allow any</li>
      *     <li>"none" or null means</li>
      *     <li>"0" is not allowed</li>
@@ -251,7 +251,7 @@ public static AffinityLock acquireLock(String desc) {
 
         } else if (desc.startsWith("csv:")) {
             String content = desc.substring(4);
-            int[] cpus = Arrays.asList(content.split(",")).stream()
+            int[] cpus = Arrays.stream(content.split(","))
                     .map(String::trim)
                     .mapToInt(Integer::parseInt).toArray();
 
@@ -322,7 +322,9 @@ public static String dumpLocks() {
 
     private static boolean areAssertionsEnabled() {
         boolean debug = false;
+        //noinspection AssertWithSideEffects
         assert debug = true;
+        //noinspection ConstantValue
         return debug;
     }
 
@@ -440,7 +442,7 @@ public void close() {
     @Override
     protected void finalize() throws Throwable {
         if (bound) {
-            LOGGER.warn("Affinity lock for " + assignedThread + " was discarded rather than release()d in a controlled manner.", boundHere);
+            LOGGER.warn("Affinity lock for {} was discarded rather than release()d in a controlled manner.", assignedThread, boundHere);
             release();
         }
         super.finalize();
diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java b/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
index 91bd4d29b..7f789a4e5 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityThreadFactory.java
@@ -53,13 +53,11 @@ public AffinityThreadFactory(String name, boolean daemon, @NotNull AffinityStrat
     public synchronized Thread newThread(@NotNull final Runnable r) {
         String name2 = id <= 1 ? name : (name + '-' + id);
         id++;
-        Thread t = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                try (AffinityLock ignored = acquireLockBasedOnLast()) {
-                    assert ignored != null;
-                    r.run();
-                }
+        Thread t = new Thread(() -> {
+            try (AffinityLock ignored = acquireLockBasedOnLast()) {
+                //noinspection ConstantValue
+                assert ignored != null;
+                r.run();
             }
         }, name2);
         t.setDaemon(daemon);
diff --git a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
index 9dfa07f9d..7939cb8c5 100644
--- a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
+++ b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
@@ -17,9 +17,11 @@
 
 package net.openhft.affinity;
 
+import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.*;
 import java.nio.file.attribute.BasicFileAttributes;
@@ -41,7 +43,7 @@ private static Set<String> getResourcesOnBootClasspath() {
         final String bootClassPath = System.getProperty("sun.boot.class.path", "");
         logger.trace("Boot class-path is: {}", bootClassPath);
 
-        final String pathSeparator = System.getProperty("path.separator");
+        final String pathSeparator = File.pathSeparator;
         logger.trace("Path separator is: '{}'", pathSeparator);
 
         final String[] pathElements = bootClassPath.split(pathSeparator);
@@ -87,7 +89,7 @@ private static Set<String> findResourcesInDirectory(final Path path, final Logge
         try {
             Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
                 @Override
-                public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
+                public @NotNull FileVisitResult visitFile(final @NotNull Path file, final @NotNull BasicFileAttributes attrs) throws IOException {
                     if (file.getFileName().toString().endsWith(".class")) {
                         dirResources.add(path.relativize(file).toString());
                     }
@@ -95,7 +97,7 @@ public FileVisitResult visitFile(final Path file, final BasicFileAttributes attr
                 }
             });
         } catch (IOException e) {
-            logger.warn("Error walking dir: " + path, e);
+            logger.warn("Error walking dir: {}", path, e);
         }
 
         return dirResources;
diff --git a/affinity/src/main/java/net/openhft/affinity/LockInventory.java b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
index fd94eb263..73bb7624c 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockInventory.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
@@ -53,7 +53,7 @@ public static String dumpLocks(@NotNull AffinityLock[] locks) {
         for (int i = 0; i < locks.length; i++) {
             AffinityLock al = locks[i];
             sb.append(i).append(": ");
-            sb.append(al.toString());
+            sb.append(al);
             sb.append('\n');
         }
         return sb.toString();
@@ -90,7 +90,7 @@ private static boolean updateLockForCurrentThread(final boolean bind, final Affi
             throw e;
 
         } catch (IOException e) {
-            LOGGER.info("Error occurred acquiring lock, trying another " + e);
+            LOGGER.info("Error occurred acquiring lock, trying another {}", String.valueOf(e));
         }
         return false;
     }
@@ -108,6 +108,8 @@ public final synchronized void set(CpuLayout cpuLayout) {
             final boolean base = AffinityLock.BASE_AFFINITY.get(i);
             final boolean reservable = AffinityLock.RESERVED_AFFINITY.get(i);
             LOGGER.trace("cpu {} base={} reservable= {}", i, base, reservable);
+            assert logicalCoreLocks != null;
+            @SuppressWarnings("resource")
             AffinityLock lock = logicalCoreLocks[i] = newLock(i, base, reservable);
 
             int layoutId = lock.cpuId();
diff --git a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
index 3b5ebef95..57851b9e3 100644
--- a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
+++ b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
@@ -40,6 +40,7 @@ public class MicroJitterSampler {
     private static void pause() throws InterruptedException {
         if (BUSYWAIT) {
             long now = System.nanoTime();
+            //noinspection StatementWithEmptyBody
             while (System.nanoTime() - now < 1_000_000) ;
         } else {
             Thread.sleep(1);
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
index df5cbbc3d..f5b5bdeb2 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
@@ -183,7 +183,7 @@ int sched_getaffinity(final int pid,
     public static class utsname extends Structure {
         public static final int _UTSNAME_LENGTH = 65;
 
-        static List<String> FIELD_ORDER = Arrays.asList(
+        static final List<String> FIELD_ORDER = Arrays.asList(
                 "sysname",
                 "nodename",
                 "release",
@@ -195,32 +195,32 @@ public static class utsname extends Structure {
         /**
          * Name of the implementation of the operating system.
          */
-        public byte[] sysname = new byte[_UTSNAME_LENGTH];
+        public final byte[] sysname = new byte[_UTSNAME_LENGTH];
 
         /**
          * Name of this node on the network.
          */
-        public byte[] nodename = new byte[_UTSNAME_LENGTH];
+        public final byte[] nodename = new byte[_UTSNAME_LENGTH];
 
         /**
          * Current release level of this implementation.
          */
-        public byte[] release = new byte[_UTSNAME_LENGTH];
+        public final byte[] release = new byte[_UTSNAME_LENGTH];
 
         /**
          * Current version level of this release.
          */
-        public byte[] version = new byte[_UTSNAME_LENGTH];
+        public final byte[] version = new byte[_UTSNAME_LENGTH];
 
         /**
          * Name of the hardware type the system is running on.
          */
-        public byte[] machine = new byte[_UTSNAME_LENGTH];
+        public final byte[] machine = new byte[_UTSNAME_LENGTH];
 
         /**
          * NIS or YP domain name
          */
-        public byte[] domainname = new byte[_UTSNAME_LENGTH];
+        public final byte[] domainname = new byte[_UTSNAME_LENGTH];
 
         static int length(final byte[] data) {
             int len = 0;
@@ -286,8 +286,8 @@ public static class cpu_set_t extends Structure {
         static final int __CPU_SETSIZE = 1024;
         static final int __NCPUBITS = 8 * NativeLong.SIZE;
         static final int SIZE_OF_CPU_SET_T = (__CPU_SETSIZE / __NCPUBITS) * NativeLong.SIZE;
-        static List<String> FIELD_ORDER = Collections.singletonList("__bits");
-        public NativeLong[] __bits = new NativeLong[__CPU_SETSIZE / __NCPUBITS];
+        static final List<String> FIELD_ORDER = Collections.singletonList("__bits");
+        public final NativeLong[] __bits = new NativeLong[__CPU_SETSIZE / __NCPUBITS];
 
         public cpu_set_t() {
             for (int i = 0; i < __bits.length; i++) {
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
index 3ec4d2730..313f8c8ec 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/LinuxJNAAffinity.java
@@ -52,7 +52,7 @@ public enum LinuxJNAAffinity implements IAffinity {
             loaded = true;
         } catch (NoClassDefFoundError | UnsatisfiedLinkError e) {
             if (IS_LINUX)
-                LOGGER.warn("Unable to load jna library {}", e);
+                LOGGER.warn("Unable to load jna library", e);
         }
         LOADED = loaded;
     }
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
index 261c23bfa..50b0f299d 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/PosixJNAAffinity.java
@@ -63,7 +63,7 @@ public enum PosixJNAAffinity implements IAffinity {
             INSTANCE.getAffinity();
             loaded = true;
         } catch (UnsatisfiedLinkError e) {
-            LOGGER.warn("Unable to load jna library {}", e);
+            LOGGER.warn("Unable to load jna library", e);
         }
         LOADED = loaded;
     }
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
index d3e9c89c1..7c17d1788 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
@@ -23,6 +23,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.io.*;
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 
 import static java.lang.Integer.parseInt;
@@ -114,7 +115,7 @@ private static InputStream openFile(String filename) throws FileNotFoundExceptio
 
     @NotNull
     public static VanillaCpuLayout fromCpuInfo(InputStream is) throws IOException {
-        BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+        BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
         String line;
         List<CpuInfo> cpuDetails = new ArrayList<>();
         CpuInfo details = new CpuInfo();
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java b/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
index 5ad224302..616f49232 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/VersionHelper.java
@@ -30,7 +30,7 @@ public VersionHelper(int major_, int minor_, int release_) {
     }
 
     public VersionHelper(String ver) {
-        if (ver != null && (ver = ver.trim()).length() > 0) {
+        if (ver != null && !(ver = ver.trim()).isEmpty()) {
             final String[] parts = ver.split("\\.");
             major = parts.length > 0 ? Integer.parseInt(parts[0]) : 0;
             minor = parts.length > 1 ? Integer.parseInt(parts[1]) : 0;
@@ -46,7 +46,7 @@ public String toString() {
     }
 
     public boolean equals(Object o) {
-        if (o != null && (o instanceof VersionHelper)) {
+        if (o instanceof VersionHelper) {
             VersionHelper ver = (VersionHelper) o;
             return this.major == ver.major
                     && this.minor == ver.minor
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
index 27b3af156..96e196178 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/WindowsJNAAffinity.java
@@ -89,8 +89,9 @@ public void setAffinity(final BitSet affinity) {
             throw new IllegalStateException("SetThreadAffinityMask((" + pid + ") , &(" + affinity + ") ) errorNo=" + e.getErrorCode(), e);
         }
         BitSet affinity2 = getAffinity0();
+        assert affinity2 != null;
         if (!affinity2.equals(affinity)) {
-            LoggerFactory.getLogger(WindowsJNAAffinity.class).warn("Tried to set affinity to " + affinity + " but was " + affinity2 + " you may have insufficient access rights");
+            LoggerFactory.getLogger(WindowsJNAAffinity.class).warn("Tried to set affinity to {} but was {} you may have insufficient access rights", affinity, affinity2);
         }
         currentAffinity.set((BitSet) affinity.clone());
     }
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
index c13040e1d..3551feab9 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
@@ -72,7 +72,7 @@ public synchronized boolean isLockFree(int id) {
             try (final FileLock fileLock = channel.tryLock(0, Long.MAX_VALUE, true)) {
                 if (fileLock != null && fileLock.isValid()) {
                     if (!lockFile.delete()) { // try and clean up the orphaned lock file
-                        LOGGER.debug("Couldn't delete orphaned lock file " + lockFile);
+                        LOGGER.debug("Couldn't delete orphaned lock file {}", lockFile);
                     }
                     return true;
                 } else {
@@ -112,7 +112,7 @@ public synchronized boolean obtainLock(int id, String metaInfo) throws IOExcepti
                 attempt++;
             }
         }
-        LOGGER.warn("Exceeded maximum retries for locking CPU " + id + ", failing acquire");
+        LOGGER.warn("Exceeded maximum retries for locking CPU {}, failing acquire", id);
         return false;
     }
 
@@ -163,6 +163,7 @@ private void writeMetaInfoToFile(FileChannel fc, String metaInfo) throws IOExcep
         byte[] content = String.format("%s%n%s", metaInfo, dfTL.get().format(new Date())).getBytes();
         ByteBuffer buffer = ByteBuffer.wrap(content);
         while (buffer.hasRemaining()) {
+            //noinspection ResultOfMethodCallIgnored
             fc.write(buffer);
         }
     }
@@ -172,7 +173,7 @@ public synchronized boolean releaseLock(int id) {
         if (locks[id] != null) {
             final File lockFile = toFile(id);
             if (!lockFile.delete()) {
-                LOGGER.warn("Couldn't delete lock file on release: " + lockFile);
+                LOGGER.warn("Couldn't delete lock file on release: {}", lockFile);
             }
             closeQuietly(locks[id].lock, locks[id].channel);
             locks[id] = null;
@@ -188,7 +189,7 @@ private void closeQuietly(AutoCloseable... closeables) {
                     closeable.close();
                 }
             } catch (Exception e) {
-                LOGGER.warn("Error closing " + closeable.getClass().getName(), e);
+                LOGGER.warn("Error closing {}", closeable.getClass().getName(), e);
             }
         }
     }
@@ -230,7 +231,7 @@ private File tmpDir() {
         final File tempDir = new File(System.getProperty("java.io.tmpdir"));
 
         if (!tempDir.exists())
-            tempDir.mkdirs();
+            tempDir.mkdirs(); // should warn if it fails
 
         return tempDir;
     }
@@ -238,7 +239,7 @@ private File tmpDir() {
     /**
      * Thrown when another process deleted the lock file between us opening the file and acquiring the lock
      */
-    class ConcurrentLockFileDeletionException extends Exception {
+    static class ConcurrentLockFileDeletionException extends Exception {
         private static final long serialVersionUID = 0L;
     }
 }
diff --git a/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java b/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
index 01ec845b3..78ca56302 100644
--- a/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
+++ b/affinity/src/main/java/net/openhft/affinity/main/AffinityTestMain.java
@@ -29,11 +29,11 @@ public class AffinityTestMain {
 
     public static void main(String[] args) {
 
-        int cpus = 1;
+        int cpus;
         if (args.length == 0) {
             cpus = AffinityLock.cpuLayout().cpus() / 12;
         } else {
-            cpus = Integer.valueOf(args[0]);
+            cpus = Integer.parseInt(args[0]);
         }
 
         for (int i = 0; i < cpus; i++) {
@@ -50,9 +50,10 @@ private static void acquireAndDoWork() {
                 System.out.println("Thread (" + threadName + ") locked onto cpu " + al.cpuId());
 
                 while (true) {
-                    System.out.println(df.format(new Date()) + " - Thread (" + threadName + ") doing work on cpu " + al.cpuId() + ". IsAllocated = " + al.isAllocated() + ", isBound = " + al.isBound() + ". " + al.toString());
+                    System.out.println(df.format(new Date()) + " - Thread (" + threadName + ") doing work on cpu " + al.cpuId() + ". IsAllocated = " + al.isAllocated() + ", isBound = " + al.isBound() + ". " + al);
 
                     try {
+                        //noinspection BusyWait
                         Thread.sleep(10000L);
                     } catch (InterruptedException e) {
                         //nothing
diff --git a/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java b/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
index b493d6020..58cb01ab6 100644
--- a/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
+++ b/affinity/src/main/java/net/openhft/ticker/impl/JNIClock.java
@@ -65,13 +65,14 @@ static long tscToNano(final long tsc) {
         return (tsc * RDTSC_FACTOR) >> FACTOR_BITS;
     }
 
+    @SuppressWarnings("StatementWithEmptyBody")
     private static void estimateFrequency(int factor) {
         final long start = System.nanoTime();
         long now;
-        while ((now = System.nanoTime()) == start) {
+        while (System.nanoTime() == start) {
         }
 
-        long end = start + factor * 1000000;
+        long end = start + factor * 1000000L;
         final long start0 = rdtsc0();
         while ((now = System.nanoTime()) < end) {
         }
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index f4d8bf76e..617be2f79 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -21,7 +21,6 @@
 import net.openhft.affinity.impl.VanillaCpuLayout;
 import net.openhft.affinity.testimpl.TestFileLockBasedLockChecker;
 import org.hamcrest.MatcherAssert;
-import org.jetbrains.annotations.NotNull;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -223,14 +222,11 @@ public void testAffinity() throws InterruptedException {
         try (AffinityLock al = AffinityLock.acquireLock()) {
             System.out.println("Main locked");
             displayStatus();
-            Thread t = new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    AffinityLock al2 = al.acquireLock(AffinityStrategies.SAME_SOCKET, AffinityStrategies.ANY);
-                    System.out.println("Thread-0 locked");
-                    displayStatus();
-                    al2.release();
-                }
+            Thread t = new Thread(() -> {
+                AffinityLock al2 = al.acquireLock(AffinityStrategies.SAME_SOCKET, AffinityStrategies.ANY);
+                System.out.println("Thread-0 locked");
+                displayStatus();
+                al2.release();
             });
             t.start();
             t.join();
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
index 9b7960e01..9052239b3 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryMain.java
@@ -37,16 +37,14 @@ private AffinityThreadFactoryMain() {
 
     public static void main(String... args) throws InterruptedException {
         for (int i = 0; i < 12; i++)
-            ES.submit(new Callable<Void>() {
-                @Override
-                public Void call() throws InterruptedException {
-                    Thread.sleep(100);
-                    return null;
-                }
+            ES.submit((Callable<Void>) () -> {
+                Thread.sleep(100);
+                return null;
             });
         Thread.sleep(200);
         System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks());
         ES.shutdown();
+        //noinspection ResultOfMethodCallIgnored
         ES.awaitTermination(1, TimeUnit.SECONDS);
     }
 }
diff --git a/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
index ed96007fb..6aa948297 100644
--- a/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/MultiProcessAffinityTest.java
@@ -53,7 +53,7 @@ public void setUp() {
     }
 
     @Test
-    public void shouldNotAcquireLockOnCoresLockedByOtherProcesses() throws IOException, InterruptedException {
+    public void shouldNotAcquireLockOnCoresLockedByOtherProcesses() throws InterruptedException {
         // run the separate affinity locker
         final Process affinityLockerProcess = JavaProcessBuilder.create(AffinityLockerProcess.class)
                 .withJvmArguments("-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath())
@@ -64,6 +64,7 @@ public void shouldNotAcquireLockOnCoresLockedByOtherProcesses() throws IOExcepti
             // wait for the CPU to be locked
             long endTime = System.currentTimeMillis() + 5_000;
             while (LockCheck.isCpuFree(lastCpuId)) {
+                //noinspection BusyWait
                 Thread.sleep(100);
                 if (System.currentTimeMillis() > endTime) {
                     LOGGER.info("Timed out waiting for the lock to be acquired: isAlive={}, exitCode={}",
@@ -83,7 +84,7 @@ public void shouldNotAcquireLockOnCoresLockedByOtherProcesses() throws IOExcepti
     }
 
     @Test
-    public void shouldAllocateCoresCorrectlyUnderContention() throws IOException, InterruptedException {
+    public void shouldAllocateCoresCorrectlyUnderContention() throws InterruptedException {
         final int numberOfLockers = Math.max(2, Math.min(12, Runtime.getRuntime().availableProcessors())) / 2;
         List<Process> lockers = new ArrayList<>();
         LOGGER.info("Running test with {} locker processes", numberOfLockers);
@@ -99,7 +100,7 @@ public void shouldAllocateCoresCorrectlyUnderContention() throws IOException, In
     }
 
     @Test
-    public void shouldAllocateCoresCorrectlyUnderContentionWithFailures() throws IOException, InterruptedException {
+    public void shouldAllocateCoresCorrectlyUnderContentionWithFailures() throws InterruptedException {
         final int numberOfLockers = Math.max(2, Math.min(12, Runtime.getRuntime().availableProcessors())) / 2;
         List<Process> lockers = new ArrayList<>();
         LOGGER.info("Running test with {} locker processes", numberOfLockers);
@@ -118,7 +119,7 @@ public void shouldAllocateCoresCorrectlyUnderContentionWithFailures() throws IOE
     }
 
     @Test
-    public void shouldBeAbleToAcquireLockLeftByOtherProcess() throws IOException, InterruptedException {
+    public void shouldBeAbleToAcquireLockLeftByOtherProcess() throws InterruptedException {
         final Process process = JavaProcessBuilder.create(AffinityLockerThatDoesNotReleaseProcess.class)
                 .withJvmArguments("-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath())
                 .withProgramArguments("last").start();
@@ -214,12 +215,12 @@ public static void main(String[] args) {
             String cpuIdToLock = args[0];
 
             try (final AffinityLock affinityLock = AffinityLock.acquireLock(cpuIdToLock)) {
-                LOGGER.info("Got affinity lock " + affinityLock + " at " + LocalDateTime.now() + ", CPU=" + affinityLock.cpuId());
+                LOGGER.info("Got affinity lock {} at {}, CPU={}", affinityLock, LocalDateTime.now(), affinityLock.cpuId());
                 Thread.sleep(Integer.MAX_VALUE);
                 LOGGER.error("Woke from sleep? this should never happen");
             } catch (InterruptedException e) {
                 // expected, just end
-                LOGGER.info("Interrupted at " + LocalDateTime.now() + " lock is released");
+                LOGGER.info("Interrupted at {} lock is released", LocalDateTime.now());
             }
         }
     }
@@ -228,13 +229,13 @@ public static void main(String[] args) {
      * Acquires a lock then ends
      */
     static class AffinityLockerThatDoesNotReleaseProcess {
-        private static final Logger LOGGER = LoggerFactory.getLogger(AffinityLockerProcess.class);
+        private static final Logger LOGGER = LoggerFactory.getLogger(AffinityLockerThatDoesNotReleaseProcess.class);
 
         public static void main(String[] args) {
             String cpuIdToLock = args[0];
 
             final AffinityLock affinityLock = AffinityLock.acquireLock(cpuIdToLock);
-            LOGGER.info("Got affinity lock " + affinityLock + " at " + LocalDateTime.now() + ", CPU=" + affinityLock.cpuId());
+            LOGGER.info("Got affinity lock {} at {}, CPU={}", affinityLock, LocalDateTime.now(), affinityLock.cpuId());
         }
     }
 
@@ -253,12 +254,14 @@ public static void main(String[] args) throws InterruptedException, IOException
                             final long maxValue = Long.MAX_VALUE; // a PID that never exists
                             ByteBuffer buffer = ByteBuffer.wrap((maxValue + "\n").getBytes(StandardCharsets.UTF_8));
                             while (buffer.hasRemaining()) {
+                                //noinspection ResultOfMethodCallIgnored
                                 fc.write(buffer);
                             }
                         }
                     } catch (FileAlreadyExistsException e) {
                         LOGGER.info("Failed, trying again");
                     }
+                    //noinspection BusyWait
                     Thread.sleep(ThreadLocalRandom.current().nextInt(50));
                 }
             }
diff --git a/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java b/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
index 02ed43383..5757e32ba 100644
--- a/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/impl/AbstractAffinityImplTest.java
@@ -23,8 +23,7 @@
 
 import java.util.BitSet;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /**
  * @author cheremin
@@ -49,10 +48,7 @@ public void getAffinityCompletesGracefully() {
     @Test
     public void getAffinityReturnsValidValue() {
         final BitSet affinity = getImpl().getAffinity();
-        assertTrue(
-                "Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty",
-                !affinity.isEmpty()
-        );
+        assertFalse("Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty", affinity.isEmpty());
         final long allCoresMask = (1L << CORES) - 1;
         assertTrue(
                 "Affinity mask " + Utilities.toBinaryString(affinity) + " must be <=(2^" + CORES + "-1 = " + allCoresMask + ")",
diff --git a/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java b/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
index db6fa69f4..85f0d7372 100644
--- a/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
+++ b/affinity/src/test/java/software/chronicle/enterprise/internals/JnaAffinityTest.java
@@ -27,8 +27,7 @@
 
 import java.util.BitSet;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /**
  * @author peter.lawrey
@@ -54,10 +53,7 @@ public void getAffinityCompletesGracefully() {
     @Test
     public void getAffinityReturnsValidValue() {
         final BitSet affinity = getImpl().getAffinity();
-        assertTrue(
-                "Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty",
-                !affinity.isEmpty()
-        );
+        assertFalse("Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty", affinity.isEmpty());
         final int allCoresMask = (1 << CORES) - 1;
         assertTrue(
                 "Affinity mask " + Utilities.toBinaryString(affinity) + " must be <=(2^" + CORES + "-1 = " + allCoresMask + ")",
@@ -80,8 +76,7 @@ public void getAffinityReturnsValuePreviouslySet() {
             return;
         }
         final IAffinity impl = LinuxJNAAffinity.INSTANCE;
-        final int cores = CORES;
-        for (int core = 0; core < cores; core++) {
+        for (int core = 0; core < CORES; core++) {
             final BitSet mask = new BitSet();
             mask.set(core, true);
             getAffinityReturnsValuePreviouslySet(impl, mask);
diff --git a/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java b/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
index 33de98652..6534082b6 100644
--- a/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
+++ b/affinity/src/test/java/software/chronicle/enterprise/internals/NativeAffinityTest.java
@@ -25,8 +25,7 @@
 
 import java.util.BitSet;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /**
  * @author peter.lawrey
@@ -52,10 +51,7 @@ public void getAffinityCompletesGracefully() {
     @Test
     public void getAffinityReturnsValidValue() {
         final BitSet affinity = getImpl().getAffinity();
-        assertTrue(
-                "Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty",
-                !affinity.isEmpty()
-        );
+        assertFalse("Affinity mask " + Utilities.toBinaryString(affinity) + " must be non-empty", affinity.isEmpty());
         final int allCoresMask = (1 << CORES) - 1;
         assertTrue(
                 "Affinity mask " + Utilities.toBinaryString(affinity) + " must be <=(2^" + CORES + "-1 = " + allCoresMask + ")",
@@ -79,8 +75,7 @@ public void getAffinityReturnsValuePreviouslySet() {
             return;
         }
         final IAffinity impl = NativeAffinity.INSTANCE;
-        final int cores = CORES;
-        for (int core = 0; core < cores; core++) {
+        for (int core = 0; core < CORES; core++) {
             final BitSet mask = new BitSet();
             mask.set(core, true);
             getAffinityReturnsValuePreviouslySet(impl, mask);

From 58469c16615930f2787897926cee05d2bb6afcce Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:44:44 +0100
Subject: [PATCH 05/53] docs: explain affinity mask

---
 README.adoc | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..2febccba8 100644
--- a/README.adoc
+++ b/README.adoc
@@ -54,7 +54,20 @@ The library looks for isolated CPUs determined by looking at the CPUs you are no
 i.e. if you have 16 CPUs but 8 of them are not available for general use (as determined by the affinity of the process on startup) it will start assigning to those CPUs.
 
 Note: if you have more than one process using this library you need to specify which CPUs the process can use otherwise it will assign the same CPUs to both processes.
-To control which CPUs a process can use, add -Daffinity.reserved={cpu-mask-in-hex} to the command line of the process.
+
+To control which CPUs a process can use, add `-Daffinity.reserved={cpu-mask-in-hex}`
+to the command line of the process. The mask is a hexadecimal bit mask without
+the `0x` prefix where bit `0` represents CPU `0`, bit `1` represents CPU `1` and
+so on. Multiple CPUs can be specified by setting more than one bit.
+
+For example:
+
+* `-Daffinity.reserved=2` reserves only CPU `1`.
+* `-Daffinity.reserved=6` reserves CPUs `1` and `2`.
+* `-Daffinity.reserved=10` reserves CPUs `1` and `3` (hexadecimal `a`).
+
+Use an appropriate mask when starting each process to avoid reserving the same
+cores for multiple JVMs.
 
 Note: the CPU 0 is reserved for the Operating System, it has to run somewhere.
 

From a37013c80e80b4da7ae67f9f6212feb6b5eb129a Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:45:05 +0100
Subject: [PATCH 06/53] Add AffinityThreadFactory example

---
 README.adoc | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..2519f016e 100644
--- a/README.adoc
+++ b/README.adoc
@@ -185,6 +185,25 @@ $ for i in "$(ls cpu-*)";
 
 ----
 
+== Using AffinityThreadFactory
+
+`AffinityThreadFactory` binds each thread it creates according to a set of
+`AffinityStrategy` rules.  This allows executors to automatically run tasks on
+cores selected by the library.
+
+[source, java]
+----
+ExecutorService es = Executors.newFixedThreadPool(4,
+        new AffinityThreadFactory("worker",
+                AffinityStrategies.SAME_CORE,
+                AffinityStrategies.DIFFERENT_SOCKET,
+                AffinityStrategies.ANY));
+es.submit(() -> {
+    // your task here
+});
+System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks());
+----
+
 == Support Material
 
 https://groups.google.com/forum/?hl=en-GB#!forum/java-thread-affinity[Java Thread Affinity support group]

From 19399a082c98b49f03c6f18e7c21a4e438b38f3e Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:45:29 +0100
Subject: [PATCH 07/53] docs: add OSGi bundle deployment instructions

---
 README.adoc | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..d7f1bb9e4 100644
--- a/README.adoc
+++ b/README.adoc
@@ -249,3 +249,17 @@ try (AffinityLock lock = AffinityLock.acquireLock("0")) { // prints a warning
     assertFalse(lock.bound);
 }
 ----
+
+== Deploying the OSGi Bundle
+
+The ``affinity-test`` module is packaged as an OSGi ``bundle``. Build it with
+
+[source,bash]
+----
+mvn -pl affinity-test clean package
+----
+
+The resulting JAR can be deployed to your OSGi runtime (e.g. Apache Felix or
+Equinox) by copying it into the framework's ``bundle`` directory or by using the
+``install`` and ``start`` commands. For a reference example, see
+``affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java``.

From 1c5e68bf881ec7547df333f98b2e2ff604b74564 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:46:29 +0100
Subject: [PATCH 08/53] docs: document affinity strategies

---
 README.adoc | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..3b0671169 100644
--- a/README.adoc
+++ b/README.adoc
@@ -127,7 +127,21 @@ try (final AffinityLock al = AffinityLock.acquireLock()) {
     t.start();
 }
 ----    
-In this example, the library will prefer a free CPU on the same Socket as the first thread, otherwise it will pick any free CPU. 
+In this example, the library will prefer a free CPU on the same Socket as the first thread, otherwise it will pick any free CPU.
+
+=== Affinity strategies
+The `AffinityStrategies` enum defines hints for selecting a CPU relative to an existing lock.
+
+[options="header",cols="1,3"]
+|===
+| Strategy | Meaning
+
+|`ANY`|Use any available CPU.
+|`SAME_CORE`|Select a CPU on the same core.
+|`SAME_SOCKET`|Select a CPU on the same socket but a different core.
+|`DIFFERENT_CORE`|Select a CPU on another core (possibly another socket).
+|`DIFFERENT_SOCKET`|Select a CPU on a different socket.
+|===
 
 === Getting the thread id
 You can get the current thread id using

From 702558dec7ffaf602332e55b31c9da9dec3ccee1 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:47:06 +0100
Subject: [PATCH 09/53] docs: explain dumpLocks output

---
 README.adoc | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..625a67da8 100644
--- a/README.adoc
+++ b/README.adoc
@@ -157,10 +157,29 @@ long reservedAffinity = AffinityLock.RESERVED_AFFINITY;
 ----    
 If you want to get/set the affinity directly you can do
 [source, java]
----- 
+----
 long currentAffinity = AffinitySupport.getAffinity();
 AffinitySupport.setAffinity(1L << 5); // lock to CPU 5.
-----   
+----
+
+=== Understanding dumpLocks() output
+
+Several examples print the current CPU assignments using `AffinityLock.dumpLocks()`.
+Each line of the output begins with the zero based CPU id followed by the status
+of that CPU. Example output might look like:
+
+[source]
+----
+0: Reserved for this application
+1: Thread[reader,5,main] alive=true
+2: General use CPU
+3: CPU not available
+----
+
+The number on each line is the logical CPU index as recognised by the library.
+The text after the colon describes whether that CPU is free, reserved or already
+bound to a thread. Use these indices when calling `AffinityLock.acquireLock(n)`
+or when constructing explicit affinity masks.
 
 === Debugging affinity state
 

From aec20bb4f55e52e2b527b8cf19d4b9941508b3b3 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:48:35 +0100
Subject: [PATCH 10/53] Add Windows JNA install instructions

---
 README.adoc | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..4bec489f5 100644
--- a/README.adoc
+++ b/README.adoc
@@ -47,6 +47,12 @@ for the artifacts `jna` and `jna-platform` in the project's `pom` file.
 
     sudo yum install jna
 
+=== Installing JNA on Windows
+
+    choco install jna
+
+Or download jna.jar and jna-platform.jar from the JNA project and add them to your classpath.
+
 === How does CPU allocation work?
 The library will read your `/proc/cpuinfo` if you have one or provide one and it will determine your CPU layout.  If you don't have one it will assume every CPU is on one CPU socket.
 

From d02ff2f0328f88dfa5d5886375e10885e201eeb6 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:50:05 +0100
Subject: [PATCH 11/53] Add isolcpus bootloader instructions

---
 README.adoc | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..11369daa2 100644
--- a/README.adoc
+++ b/README.adoc
@@ -76,6 +76,21 @@ To isolate the 1st and 3rd CPU cores (CPU numbers start from 0) on your system,
 
 isolcpus=1,3
 
+Using GRUB
+[source]
+----
+sudo sed -i 's/^GRUB_CMDLINE_LINUX_DEFAULT="/GRUB_CMDLINE_LINUX_DEFAULT="isolcpus=1,3 /' /etc/default/grub
+sudo update-grub
+sudo reboot
+----
+
+Using systemd-boot
+[source]
+----
+sudo sed -i 's/^options \(.*\)/options \1 isolcpus=1,3/' /boot/loader/entries/*.conf
+sudo reboot
+----
+
 == Using AffinityLock
 
 === Acquiring a CPU lock for a thread

From f7726508f9c25a682d5d2e7558d0c33c0153e014 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:50:38 +0100
Subject: [PATCH 12/53] docs: describe supported OS features

---
 README.adoc | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..3324dda2a 100644
--- a/README.adoc
+++ b/README.adoc
@@ -17,6 +17,20 @@ OpenHFT Java Thread Affinity library
 See https://github.com/OpenHFT/Java-Thread-Affinity/tree/master/affinity/src/test/java[affinity/src/test/java] 
 for working examples of how to use this library.
 
+=== Supported operating systems
+
+The library detects the running platform in `Affinity.java` and selects an
+implementation for that OS. Features differ between systems:
+
+* *Linux* - full affinity control via JNA. The implementation can get and set
+  thread affinity, query the current CPU, and obtain process and thread IDs.
+* *Windows* - thread affinity is managed through the kernel API. Process and
+  thread IDs are available, while `getCpu()` returns `-1`.
+* *macOS* - provides process and thread IDs but does not modify affinity and
+  reports the CPU id as `-1`.
+* *Solaris* - mirrors the macOS implementation: only process and thread IDs are
+  returned with no affinity or CPU querying support.
+
 === Changes
 
 * V3.2.0 - Add support for text configuration

From 1e25e24aca9e2ed497c02459ddbda520f7ad63a5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:51:51 +0100
Subject: [PATCH 13/53] docs: clarify lock file directory

---
 README.adoc | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/README.adoc b/README.adoc
index 773c4ffa7..90f5ed8aa 100644
--- a/README.adoc
+++ b/README.adoc
@@ -160,7 +160,28 @@ If you want to get/set the affinity directly you can do
 ---- 
 long currentAffinity = AffinitySupport.getAffinity();
 AffinitySupport.setAffinity(1L << 5); // lock to CPU 5.
-----   
+----
+
+=== Lock file directory
+
+AffinityLock stores a small lock file for each CPU. These files are placed in
+the directory specified by the `java.io.tmpdir` system property, which by
+default points to your system's temporary directory (usually `/tmp` on Linux).
+
+If you want to keep the lock files elsewhere, set this property before using any
+affinity APIs:
+
+[source, bash]
+----
+java -Djava.io.tmpdir=/path/to/dir ...
+----
+
+or in code
+
+[source, java]
+----
+System.setProperty("java.io.tmpdir", "/path/to/dir");
+----
 
 === Debugging affinity state
 

From 047439b8e52b1290f1ea23c616393f2546dea2ac Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:52:16 +0100
Subject: [PATCH 14/53] Add test to verify Ticker falls back to SystemClock

---
 .../java/net/openhft/ticker/TickerTest.java   | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/ticker/TickerTest.java

diff --git a/affinity/src/test/java/net/openhft/ticker/TickerTest.java b/affinity/src/test/java/net/openhft/ticker/TickerTest.java
new file mode 100644
index 000000000..5c803e0ad
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/ticker/TickerTest.java
@@ -0,0 +1,30 @@
+package net.openhft.ticker;
+
+import net.openhft.ticker.impl.JNIClock;
+import net.openhft.ticker.impl.SystemClock;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+import static org.junit.Assert.assertSame;
+
+public class TickerTest {
+    @Test
+    public void whenJniClockUnavailableTickerUsesSystemClock() throws Exception {
+        // Force JNIClock.LOADED to false
+        Field loadedField = JNIClock.class.getDeclaredField("LOADED");
+        loadedField.setAccessible(true);
+        Field modifiersField = Field.class.getDeclaredField("modifiers");
+        modifiersField.setAccessible(true);
+        modifiersField.setInt(loadedField, loadedField.getModifiers() & ~Modifier.FINAL);
+        loadedField.setBoolean(null, false);
+
+        // Load Ticker after modifying JNIClock.LOADED
+        Class<?> tickerClass = Class.forName("net.openhft.ticker.Ticker");
+        Field instanceField = tickerClass.getDeclaredField("INSTANCE");
+        instanceField.setAccessible(true);
+        Object instance = instanceField.get(null);
+        assertSame(SystemClock.INSTANCE, instance);
+    }
+}

From 834683c516d8dbf8b7445edee0a5748dad666edd Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:52:42 +0100
Subject: [PATCH 15/53] test lock file deletion during lock

---
 .../affinity/FileLockLockCheckTest.java       | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
index 82b64435a..9f6ffd247 100644
--- a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
@@ -71,4 +71,29 @@ public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception {
 
         LockCheck.isCpuFree(cpu);
     }
+
+    @Test
+    public void lockFileDeletedWhileHeld() throws Exception {
+        cpu++;
+
+        Assert.assertTrue(LockCheck.isCpuFree(cpu));
+        LockCheck.updateCpu(cpu);
+
+        File lockFile = lockChecker.doToFile(cpu);
+        Assert.assertTrue(lockFile.exists());
+
+        Assert.assertTrue("Could not delete lock file", lockFile.delete());
+        Assert.assertFalse(lockFile.exists());
+
+        Assert.assertFalse("CPU should remain locked despite missing file", LockCheck.isCpuFree(cpu));
+        Assert.assertEquals(LockCheck.getPID(), LockCheck.getProcessForCpu(cpu));
+
+        LockCheck.releaseLock(cpu);
+
+        Assert.assertTrue("Lock should be free after release", LockCheck.isCpuFree(cpu));
+        LockCheck.updateCpu(cpu);
+
+        lockFile = lockChecker.doToFile(cpu);
+        Assert.assertTrue("Lock file should be recreated", lockFile.exists());
+    }
 }

From ba0767530e8782a4901a20cc18034a35d83f3e71 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:53:21 +0100
Subject: [PATCH 16/53] test: verify binding two threads to same cpu

---
 .../openhft/affinity/AffinityLockTest.java    | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 617be2f79..a38274e5c 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -314,6 +314,33 @@ public void testTooHighCpuId2() {
         }
     }
 
+    @Test(expected = IllegalStateException.class)
+    public void bindingTwoThreadsToSameCpuThrows() throws InterruptedException {
+        assumeTrue(Runtime.getRuntime().availableProcessors() > 1);
+
+        final AffinityLock lock = AffinityLock.acquireLock(false);
+        Thread t = new Thread(() -> {
+            lock.bind();
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException ignored) {
+                // ignored
+            }
+        });
+        t.start();
+
+        while (!lock.isBound()) {
+            Thread.sleep(10);
+        }
+
+        try {
+            lock.bind();
+        } finally {
+            t.join();
+            lock.release();
+        }
+    }
+
     /**
      * In Java 21 the toString contents of Thread changed to include an ID. This breaks the tests here in Java 21.
      * Strip out the thread ID here so that existing tests continue to pass.

From e6b60cca894092535f3329468f8bf491d35131c3 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:53:38 +0100
Subject: [PATCH 17/53] test: verify core lock reserves all CPUs

---
 .../openhft/affinity/AffinityLockTest.java    | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 617be2f79..4236e591e 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -20,6 +20,8 @@
 import net.openhft.affinity.impl.Utilities;
 import net.openhft.affinity.impl.VanillaCpuLayout;
 import net.openhft.affinity.testimpl.TestFileLockBasedLockChecker;
+import net.openhft.affinity.CpuLayout;
+import net.openhft.affinity.LockCheck;
 import org.hamcrest.MatcherAssert;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -261,6 +263,25 @@ public void lockFilesShouldBeRemovedOnRelease() {
         assertFalse(Files.exists(Paths.get(lockChecker.doToFile(lock.cpuId()).getAbsolutePath())));
     }
 
+    @Test
+    public void wholeCoreLockReservesAllLogicalCpus() throws IOException {
+        if (!Utilities.ISLINUX || !new File("/proc/cpuinfo").exists()) {
+            return;
+        }
+        AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo());
+
+        try (AffinityLock lock = AffinityLock.acquireCore()) {
+            CpuLayout layout = AffinityLock.cpuLayout();
+            int socketId = layout.socketId(lock.cpuId());
+            int coreId = layout.coreId(lock.cpuId());
+            for (int i = 0; i < layout.cpus(); i++) {
+                if (layout.socketId(i) == socketId && layout.coreId(i) == coreId) {
+                    assertFalse("CPU " + i + " should be reserved", LockCheck.isCpuFree(i));
+                }
+            }
+        }
+    }
+
     private void displayStatus() {
         System.out.println(Thread.currentThread() + " on " + Affinity.getCpu() + "\n" + AffinityLock.dumpLocks());
     }

From de1918875b12a4c86f7310131287d6fe9b99c530 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:53:51 +0100
Subject: [PATCH 18/53] Add test for JNA load failure

---
 .../affinity/AffinityJNALoadFailureTest.java  | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java
new file mode 100644
index 000000000..92b89b153
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java
@@ -0,0 +1,46 @@
+import org.junit.Test;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertSame;
+
+public class AffinityJNALoadFailureTest {
+
+    @Test
+    public void shouldReturnNullAffinityWhenJnaFailsToLoad() throws Exception {
+        // Build URLs from current classpath
+        String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
+        List<URL> urlList = new ArrayList<>();
+        for (String p : cp) {
+            urlList.add(new File(p).toURI().toURL());
+        }
+        URLClassLoader cl = new URLClassLoader(urlList.toArray(new URL[0]), null);
+
+        // Force JNA version < 5 in the new classloader
+        Class<?> nativeCls = Class.forName("com.sun.jna.Native", true, cl);
+        Field verField = nativeCls.getDeclaredField("VERSION");
+        verField.setAccessible(true);
+        Field modField = Field.class.getDeclaredField("modifiers");
+        modField.setAccessible(true);
+        modField.setInt(verField, verField.getModifiers() & ~Modifier.FINAL);
+        Object originalVer = verField.get(null);
+        verField.set(null, "4.0.0");
+        try {
+            Class<?> affinityCls = Class.forName("net.openhft.affinity.Affinity", true, cl);
+            Method m = affinityCls.getMethod("getAffinityImpl");
+            Object impl = m.invoke(null);
+            Class<?> nullAffinityCls = Class.forName("net.openhft.affinity.impl.NullAffinity", true, cl);
+            Object expected = nullAffinityCls.getEnumConstants()[0];
+            assertSame(expected, impl);
+        } finally {
+            verField.set(null, originalVer);
+        }
+    }
+}

From 0ce42fcff74f2c99cf681ad5b82288dbeaae45ff Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:56:33 +0100
Subject: [PATCH 19/53] Add test ensuring AffinityThreadFactory assigns unique
 CPUs

---
 .../affinity/AffinityThreadFactoryTest.java   | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryTest.java
new file mode 100644
index 000000000..7377cc7ea
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityThreadFactoryTest.java
@@ -0,0 +1,55 @@
+package net.openhft.affinity;
+
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.*;
+
+public class AffinityThreadFactoryTest extends BaseAffinityTest {
+
+    @Before
+    public void checkLinux() {
+        Assume.assumeTrue(LockCheck.IS_LINUX);
+    }
+
+    @Test
+    public void threadsReceiveDistinctCpus() throws InterruptedException {
+        int available = Math.max(1, AffinityLock.PROCESSORS - 1);
+        int nThreads = Math.min(4, available);
+
+        ExecutorService es = Executors.newFixedThreadPool(nThreads,
+                new AffinityThreadFactory("test"));
+
+        Set<Integer> cpus = ConcurrentHashMap.newKeySet();
+        CountDownLatch ready = new CountDownLatch(nThreads);
+        CountDownLatch finished = new CountDownLatch(nThreads);
+
+        for (int i = 0; i < nThreads; i++) {
+            es.submit(() -> {
+                cpus.add(Affinity.getCpu());
+                ready.countDown();
+                try {
+                    ready.await();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+                finished.countDown();
+            });
+        }
+
+        assertTrue(finished.await(5, TimeUnit.SECONDS));
+        es.shutdown();
+        es.awaitTermination(5, TimeUnit.SECONDS);
+
+        assertFalse(cpus.contains(-1));
+        assertEquals(nThreads, cpus.size());
+    }
+}

From 93cd23de99252cdfc2cb131b131e32274f5bbad5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:57:07 +0100
Subject: [PATCH 20/53] Add CPU layout property samples and counts tests

---
 .../VanillaCpuLayoutPropertiesParseTest.java  | 50 +++++++++++++++++++
 .../test/resources/amd64.dual.core.properties | 18 +++++++
 .../test/resources/amd64.quad.core.properties | 20 ++++++++
 .../src/test/resources/core.duo.properties    | 18 +++++++
 .../src/test/resources/dual.E5405.properties  | 24 +++++++++
 .../src/test/resources/dual.xeon.properties   | 20 ++++++++
 affinity/src/test/resources/i3.properties     | 20 ++++++++
 .../src/test/resources/q6600.noht.properties  | 20 ++++++++
 .../src/test/resources/q6600.vm.properties    | 20 ++++++++
 9 files changed, 210 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPropertiesParseTest.java
 create mode 100644 affinity/src/test/resources/amd64.dual.core.properties
 create mode 100644 affinity/src/test/resources/amd64.quad.core.properties
 create mode 100644 affinity/src/test/resources/core.duo.properties
 create mode 100644 affinity/src/test/resources/dual.E5405.properties
 create mode 100644 affinity/src/test/resources/dual.xeon.properties
 create mode 100644 affinity/src/test/resources/i3.properties
 create mode 100644 affinity/src/test/resources/q6600.noht.properties
 create mode 100644 affinity/src/test/resources/q6600.vm.properties

diff --git a/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPropertiesParseTest.java b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPropertiesParseTest.java
new file mode 100644
index 000000000..b539ccf98
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPropertiesParseTest.java
@@ -0,0 +1,50 @@
+package net.openhft.affinity.impl;
+
+import org.junit.Test;
+
+import java.io.InputStream;
+
+import static org.junit.Assert.assertEquals;
+
+public class VanillaCpuLayoutPropertiesParseTest {
+
+    @Test
+    public void testCountsI7() throws Exception {
+        InputStream is = getClass().getClassLoader().getResourceAsStream("i7.properties");
+        VanillaCpuLayout vcl = VanillaCpuLayout.fromProperties(is);
+        assertEquals(8, vcl.cpus());
+        assertEquals(1, vcl.sockets());
+        assertEquals(4, vcl.coresPerSocket());
+        assertEquals(2, vcl.threadsPerCore());
+    }
+
+    @Test
+    public void testCountsDualXeon() throws Exception {
+        InputStream is = getClass().getClassLoader().getResourceAsStream("dual.xeon.properties");
+        VanillaCpuLayout vcl = VanillaCpuLayout.fromProperties(is);
+        assertEquals(4, vcl.cpus());
+        assertEquals(2, vcl.sockets());
+        assertEquals(1, vcl.coresPerSocket());
+        assertEquals(2, vcl.threadsPerCore());
+    }
+
+    @Test
+    public void testCountsDualE5405() throws Exception {
+        InputStream is = getClass().getClassLoader().getResourceAsStream("dual.E5405.properties");
+        VanillaCpuLayout vcl = VanillaCpuLayout.fromProperties(is);
+        assertEquals(8, vcl.cpus());
+        assertEquals(2, vcl.sockets());
+        assertEquals(4, vcl.coresPerSocket());
+        assertEquals(1, vcl.threadsPerCore());
+    }
+
+    @Test
+    public void testCountsI3() throws Exception {
+        InputStream is = getClass().getClassLoader().getResourceAsStream("i3.properties");
+        VanillaCpuLayout vcl = VanillaCpuLayout.fromProperties(is);
+        assertEquals(4, vcl.cpus());
+        assertEquals(1, vcl.sockets());
+        assertEquals(2, vcl.coresPerSocket());
+        assertEquals(2, vcl.threadsPerCore());
+    }
+}
diff --git a/affinity/src/test/resources/amd64.dual.core.properties b/affinity/src/test/resources/amd64.dual.core.properties
new file mode 100644
index 000000000..3f74c06bc
--- /dev/null
+++ b/affinity/src/test/resources/amd64.dual.core.properties
@@ -0,0 +1,18 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,1,0
diff --git a/affinity/src/test/resources/amd64.quad.core.properties b/affinity/src/test/resources/amd64.quad.core.properties
new file mode 100644
index 000000000..3f681ff10
--- /dev/null
+++ b/affinity/src/test/resources/amd64.quad.core.properties
@@ -0,0 +1,20 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,1,0
+2=0,2,0
+3=0,3,0
diff --git a/affinity/src/test/resources/core.duo.properties b/affinity/src/test/resources/core.duo.properties
new file mode 100644
index 000000000..3f74c06bc
--- /dev/null
+++ b/affinity/src/test/resources/core.duo.properties
@@ -0,0 +1,18 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,1,0
diff --git a/affinity/src/test/resources/dual.E5405.properties b/affinity/src/test/resources/dual.E5405.properties
new file mode 100644
index 000000000..d656b7376
--- /dev/null
+++ b/affinity/src/test/resources/dual.E5405.properties
@@ -0,0 +1,24 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,1,0
+2=0,2,0
+3=0,3,0
+4=1,4,0
+5=1,5,0
+6=1,6,0
+7=1,7,0
diff --git a/affinity/src/test/resources/dual.xeon.properties b/affinity/src/test/resources/dual.xeon.properties
new file mode 100644
index 000000000..36fc4ef90
--- /dev/null
+++ b/affinity/src/test/resources/dual.xeon.properties
@@ -0,0 +1,20 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,0,1
+2=3,3,0
+3=3,3,1
diff --git a/affinity/src/test/resources/i3.properties b/affinity/src/test/resources/i3.properties
new file mode 100644
index 000000000..ab4e83876
--- /dev/null
+++ b/affinity/src/test/resources/i3.properties
@@ -0,0 +1,20 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,2,0
+2=0,0,1
+3=0,2,1
diff --git a/affinity/src/test/resources/q6600.noht.properties b/affinity/src/test/resources/q6600.noht.properties
new file mode 100644
index 000000000..e2b34e4e1
--- /dev/null
+++ b/affinity/src/test/resources/q6600.noht.properties
@@ -0,0 +1,20 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,2,0
+2=0,1,0
+3=0,3,0
diff --git a/affinity/src/test/resources/q6600.vm.properties b/affinity/src/test/resources/q6600.vm.properties
new file mode 100644
index 000000000..3f681ff10
--- /dev/null
+++ b/affinity/src/test/resources/q6600.vm.properties
@@ -0,0 +1,20 @@
+#
+# Copyright 2016-2025 chronicle.software
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+0=0,0,0
+1=0,1,0
+2=0,2,0
+3=0,3,0

From edabf5a5dea989f6522cf38cae75dad9c1955ebe Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 14:59:23 +0100
Subject: [PATCH 21/53] Add detailed javadoc for ITicker

---
 .../main/java/net/openhft/ticker/ITicker.java | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/ticker/ITicker.java b/affinity/src/main/java/net/openhft/ticker/ITicker.java
index 5438e51d8..407583031 100644
--- a/affinity/src/main/java/net/openhft/ticker/ITicker.java
+++ b/affinity/src/main/java/net/openhft/ticker/ITicker.java
@@ -17,8 +17,23 @@
 
 package net.openhft.ticker;
 
-/*
- * Created by Peter Lawrey on 13/07/15.
+/**
+ * Abstraction of a high resolution time source used throughout the library.
+ * <p>
+ * Implementations may be based on {@link System#nanoTime()} or platform
+ * specific timers such as the processor&apos;s time stamp counter accessed via
+ * JNI.  The {@linkplain #ticks() tick values} returned are therefore
+ * implementation dependent.  They always increase monotonically but the unit
+ * they represent can vary from nanoseconds to CPU cycles.
+ * <p>
+ * Utility methods are provided to convert these raw ticks into conventional
+ * time units.  For example {@link #toNanos(long)} converts the supplied number
+ * of ticks to nanoseconds and {@link #toMicros(double)} converts them to
+ * microseconds.
+ * <p>
+ * This interface is typically accessed via the {@link net.openhft.ticker.Ticker}
+ * helper class which selects the best available implementation for the
+ * running platform.
  */
 public interface ITicker {
     long nanoTime();

From a306b0e38a5d6a642a8dbe5cb1bd75d53ebbbff4 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:00:13 +0100
Subject: [PATCH 22/53] Support boot class path lookup on Java 9+

---
 .../net/openhft/affinity/BootClassPath.java   | 48 ++++++++++++++++---
 .../openhft/affinity/BootClassPathTest.java   |  2 -
 2 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
index 7939cb8c5..b13d16684 100644
--- a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
+++ b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
@@ -23,6 +23,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.URI;
 import java.nio.file.*;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.Collections;
@@ -40,21 +41,56 @@ enum BootClassPath {
     private static Set<String> getResourcesOnBootClasspath() {
         final Logger logger = LoggerFactory.getLogger(BootClassPath.class);
         final Set<String> resources = new HashSet<>();
+
         final String bootClassPath = System.getProperty("sun.boot.class.path", "");
-        logger.trace("Boot class-path is: {}", bootClassPath);
+        if (!bootClassPath.isEmpty()) {
+            logger.trace("Boot class-path is: {}", bootClassPath);
 
-        final String pathSeparator = File.pathSeparator;
-        logger.trace("Path separator is: '{}'", pathSeparator);
+            final String pathSeparator = File.pathSeparator;
+            logger.trace("Path separator is: '{}'", pathSeparator);
 
-        final String[] pathElements = bootClassPath.split(pathSeparator);
+            final String[] pathElements = bootClassPath.split(pathSeparator);
 
-        for (final String pathElement : pathElements) {
-            resources.addAll(findResources(Paths.get(pathElement), logger));
+            for (final String pathElement : pathElements) {
+                resources.addAll(findResources(Paths.get(pathElement), logger));
+            }
+        } else {
+            resources.addAll(findResourcesInJrt(logger));
         }
 
         return resources;
     }
 
+    private static Set<String> findResourcesInJrt(final Logger logger) {
+        final Set<String> jrtResources = new HashSet<>();
+        try {
+            FileSystem fs;
+            try {
+                fs = FileSystems.getFileSystem(URI.create("jrt:/"));
+            } catch (FileSystemNotFoundException | ProviderNotFoundException e) {
+                fs = FileSystems.newFileSystem(URI.create("jrt:/"), Collections.emptyMap());
+            }
+            final Path modules = fs.getPath("/modules");
+            Files.walkFileTree(modules, new SimpleFileVisitor<Path>() {
+                @Override
+                public @NotNull FileVisitResult visitFile(final @NotNull Path file,
+                                                          final @NotNull BasicFileAttributes attrs) throws IOException {
+                    if (file.getFileName().toString().endsWith(".class")) {
+                        Path relative = modules.relativize(file);
+                        if (relative.getNameCount() > 1) {
+                            Path classPath = relative.subpath(1, relative.getNameCount());
+                            jrtResources.add(classPath.toString());
+                        }
+                    }
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+        } catch (IOException e) {
+            logger.warn("Error walking jrt filesystem", e);
+        }
+        return jrtResources;
+    }
+
     private static Set<String> findResources(final Path path, final Logger logger) {
         if (!Files.exists(path)) {
             return Collections.emptySet();
diff --git a/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java b/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
index bf0cb8268..9e1db8097 100644
--- a/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
@@ -23,8 +23,6 @@
 public class BootClassPathTest {
     @Test
     public void shouldDetectClassesOnClassPath() {
-        if (!System.getProperty("java.version").startsWith("1.8"))
-            return;
         assertTrue(BootClassPath.INSTANCE.has("java.lang.Thread"));
         assertTrue(BootClassPath.INSTANCE.has("java.lang.Runtime"));
     }

From fa876c49f7aded43a3fbedd812827794ff00ff69 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:01:09 +0100
Subject: [PATCH 23/53] Throw IllegalArgumentException for invalid cpuId

---
 .../main/java/net/openhft/affinity/AffinityLock.java |  6 ++++++
 .../java/net/openhft/affinity/AffinityLockTest.java  | 12 ++++--------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index 24696033c..e0b405b92 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -178,6 +178,9 @@ public static AffinityLock acquireLock(boolean bind) {
      * @return A handle for an affinity lock.
      */
     public static AffinityLock acquireLock(int cpuId) {
+        if (cpuId < 0 || cpuId >= PROCESSORS) {
+            throw new IllegalArgumentException("cpuId must be between 0 and " + (PROCESSORS - 1) + ": " + cpuId);
+        }
         return acquireLock(true, cpuId, AffinityStrategies.ANY);
     }
 
@@ -192,6 +195,9 @@ public static AffinityLock acquireLock(int cpuId) {
      */
     public static AffinityLock acquireLock(int[] cpus) {
         for (int cpu : cpus) {
+            if (cpu < 0 || cpu >= PROCESSORS) {
+                throw new IllegalArgumentException("cpuId must be between 0 and " + (PROCESSORS - 1) + ": " + cpu);
+            }
             AffinityLock lock = tryAcquireLock(true, cpu);
             if (lock != null) {
                 LOGGER.info("Acquired lock on CPU {}", cpu);
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 617be2f79..e20916aa3 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -300,18 +300,14 @@ public void testAffinityLockDescriptions() {
         }
     }
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
     public void testTooHighCpuId() {
-        try (AffinityLock ignored = AffinityLock.acquireLock(123456)) {
-            assertNotNull(ignored);
-        }
+        AffinityLock.acquireLock(123456);
     }
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
     public void testTooHighCpuId2() {
-        try (AffinityLock ignored = AffinityLock.acquireLock(new int[] {123456})) {
-            assertNotNull(ignored);
-        }
+        AffinityLock.acquireLock(new int[] {123456});
     }
 
     /**

From ce10cdd7238e77ada05e12792a5aaeda387a432b Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:02:38 +0100
Subject: [PATCH 24/53] Use ProcessHandle for pid

---
 .../java/net/openhft/affinity/LockCheck.java  |  4 +--
 .../openhft/affinity/impl/NullAffinity.java   |  4 +--
 .../openhft/affinity/impl/OSXJNAAffinity.java |  4 +--
 .../affinity/impl/SolarisJNAAffinity.java     |  4 +--
 .../net/openhft/affinity/impl/Utilities.java  | 26 +++++++++++++++++++
 5 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/LockCheck.java b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
index 259aaf40b..dc4af7429 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockCheck.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
@@ -39,9 +39,7 @@ public enum LockCheck {
     private static final LockChecker lockChecker = FileLockBasedLockChecker.getInstance();
 
     public static long getPID() {
-        String processName =
-                java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
-        return Long.parseLong(processName.split("@")[0]);
+        return Utilities.currentProcessId();
     }
 
     static boolean canOSSupportOperation() {
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
index c0b32483e..999ea12c8 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
@@ -21,7 +21,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.management.ManagementFactory;
 import java.util.BitSet;
 
 /**
@@ -48,8 +47,7 @@ public int getCpu() {
 
     @Override
     public int getProcessId() {
-        final String name = ManagementFactory.getRuntimeMXBean().getName();
-        return Integer.parseInt(name.split("@")[0]);
+        return Utilities.currentProcessId();
     }
 
     @Override
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
index 86eb05745..f01f01ebc 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
@@ -24,7 +24,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.management.ManagementFactory;
 import java.util.BitSet;
 
 /**
@@ -55,8 +54,7 @@ public int getCpu() {
 
     @Override
     public int getProcessId() {
-        final String name = ManagementFactory.getRuntimeMXBean().getName();
-        return Integer.parseInt(name.split("@")[0]);
+        return Utilities.currentProcessId();
     }
 
     @Override
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
index b0c7e1436..cc49f97a7 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
@@ -24,7 +24,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.management.ManagementFactory;
 import java.util.BitSet;
 
 /**
@@ -55,8 +54,7 @@ public int getCpu() {
 
     @Override
     public int getProcessId() {
-        final String name = ManagementFactory.getRuntimeMXBean().getName();
-        return Integer.parseInt(name.split("@")[0]);
+        return Utilities.currentProcessId();
     }
 
     @Override
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java b/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
index 676f1567f..4d3bfd13b 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/Utilities.java
@@ -79,4 +79,30 @@ private static boolean is64Bit0() {
         systemProp = System.getProperty("java.vm.version");
         return systemProp != null && systemProp.contains("_64");
     }
+
+    /**
+     * Returns the current process id. Uses {@code ProcessHandle} when running
+     * on Java&nbsp;9 or later and falls back to parsing
+     * {@code RuntimeMXBean#getName()} on earlier versions.
+     *
+     * @return the process id or {@code -1} if it cannot be determined
+     */
+    public static int currentProcessId() {
+        try {
+            // Java 9+ provides ProcessHandle which has a pid() method.
+            Class<?> phClass = Class.forName("java.lang.ProcessHandle");
+            Object current = phClass.getMethod("current").invoke(null);
+            long pid = (Long) phClass.getMethod("pid").invoke(current);
+            return (int) pid;
+        } catch (Throwable ignored) {
+            // ignore and fallback to the pre-Java 9 approach
+        }
+
+        try {
+            String name = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
+            return Integer.parseInt(name.split("@")[0]);
+        } catch (Throwable e) {
+            return -1;
+        }
+    }
 }

From dc0475c93b7d4f3eaaff23c2d6dcde16ea271e4d Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:03:17 +0100
Subject: [PATCH 25/53] Check for Thread.tid availability

---
 .../java/net/openhft/affinity/Affinity.java   | 25 ++++++++++++++++---
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/Affinity.java b/affinity/src/main/java/net/openhft/affinity/Affinity.java
index d4654749a..43bfb7ffe 100644
--- a/affinity/src/main/java/net/openhft/affinity/Affinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/Affinity.java
@@ -39,9 +39,24 @@ public enum Affinity {
     static final Logger LOGGER = LoggerFactory.getLogger(Affinity.class);
     @NotNull
     private static final IAffinity AFFINITY_IMPL;
+    /**
+     * Cached reference to {@code Thread.tid} when available, otherwise {@code null}.
+     */
+    private static final Field THREAD_TID_FIELD;
     private static Boolean JNAAvailable;
 
     static {
+        Field tidField = null;
+        try {
+            tidField = Thread.class.getDeclaredField("tid");
+            tidField.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+            LOGGER.info("Thread.tid field not present; thread id won't be set via reflection");
+        } catch (Exception e) {
+            LOGGER.warn("Unable to access Thread.tid field", e);
+        }
+        THREAD_TID_FIELD = tidField;
+
         String osName = System.getProperty("os.name");
         if (osName.contains("Win") && isWindowsJNAAffinityUsable()) {
             LOGGER.trace("Using Windows JNA-based affinity control implementation");
@@ -175,12 +190,14 @@ public static int getThreadId() {
     }
 
     public static void setThreadId() {
+        int threadId = Affinity.getThreadId();
+        if (THREAD_TID_FIELD == null) {
+            LOGGER.info("Thread.tid field unavailable; skipping setting thread id {}", threadId);
+            return;
+        }
         try {
-            int threadId = Affinity.getThreadId();
-            final Field tid = Thread.class.getDeclaredField("tid");
-            tid.setAccessible(true);
             final Thread thread = Thread.currentThread();
-            tid.setLong(thread, threadId);
+            THREAD_TID_FIELD.setLong(thread, threadId);
             Affinity.LOGGER.info("Set {} to thread id {}", thread.getName(), threadId);
         } catch (Exception e) {
             throw new IllegalStateException(e);

From ab8feb65c2e74a5f7550d1562089be644a4f55e5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:03:28 +0100
Subject: [PATCH 26/53] Replace System.err with logger warning in acquireLock

---
 affinity/src/main/java/net/openhft/affinity/AffinityLock.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index 24696033c..600c4cca1 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -271,7 +271,7 @@ public static AffinityLock acquireLock(String desc) {
             }
         }
         if (cpuId <= 0) {
-            System.err.println("Cannot allocate 0 or negative cpuIds '" + desc + "'");
+            LOGGER.warn("Cannot allocate 0 or negative cpuIds '{}'", desc);
             return LOCK_INVENTORY.noLock();
         }
         return acquireLock(cpuId);

From 67fa0e0c659c8d103673a53f4adc56cbf67ef054 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:03:41 +0100
Subject: [PATCH 27/53] Fix log message for unloaded JNI/JNA

---
 .../src/main/java/net/openhft/affinity/impl/NullAffinity.java   | 2 +-
 .../src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java | 2 +-
 .../main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
index c0b32483e..9ee9f1844 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/NullAffinity.java
@@ -38,7 +38,7 @@ public BitSet getAffinity() {
 
     @Override
     public void setAffinity(final BitSet affinity) {
-        LOGGER.trace("unable to set mask to {} as the JNIa nd JNA libraries and not loaded", Utilities.toHexString(affinity));
+        LOGGER.trace("unable to set mask to {} as the JNI and JNA libraries not loaded", Utilities.toHexString(affinity));
     }
 
     @Override
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
index 86eb05745..9a944ecc6 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/OSXJNAAffinity.java
@@ -45,7 +45,7 @@ public BitSet getAffinity() {
 
     @Override
     public void setAffinity(final BitSet affinity) {
-        LOGGER.trace("unable to set mask to {} as the JNIa nd JNA libraries and not loaded", Utilities.toHexString(affinity));
+        LOGGER.trace("unable to set mask to {} as the JNI and JNA libraries not loaded", Utilities.toHexString(affinity));
     }
 
     @Override
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
index b0c7e1436..4b58eca56 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/SolarisJNAAffinity.java
@@ -45,7 +45,7 @@ public BitSet getAffinity() {
 
     @Override
     public void setAffinity(final BitSet affinity) {
-        LOGGER.trace("unable to set mask to {} as the JNIa nd JNA libraries and not loaded", Utilities.toHexString(affinity));
+        LOGGER.trace("unable to set mask to {} as the JNI and JNA libraries not loaded", Utilities.toHexString(affinity));
     }
 
     @Override

From 3bba604bac22480ee3749808c9fc1a8d11b2c020 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:04:12 +0100
Subject: [PATCH 28/53] Add unit test for i7 cpuinfo layout mapping

---
 .../impl/CpuInfoLayoutMappingTest.java        | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/impl/CpuInfoLayoutMappingTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/impl/CpuInfoLayoutMappingTest.java b/affinity/src/test/java/net/openhft/affinity/impl/CpuInfoLayoutMappingTest.java
new file mode 100644
index 000000000..3cee5d4bc
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/impl/CpuInfoLayoutMappingTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016-2025 chronicle.software
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.affinity.impl;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.junit.Assert.assertEquals;
+
+public class CpuInfoLayoutMappingTest {
+
+    @Test
+    public void verifyI7CpuInfoMapping() throws IOException {
+        final InputStream i7 = getClass().getClassLoader().getResourceAsStream("i7.cpuinfo");
+        VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(i7);
+        assertEquals(
+                "0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" +
+                "1: CpuInfo{socketId=0, coreId=1, threadId=0}\n" +
+                "2: CpuInfo{socketId=0, coreId=2, threadId=0}\n" +
+                "3: CpuInfo{socketId=0, coreId=3, threadId=0}\n" +
+                "4: CpuInfo{socketId=0, coreId=0, threadId=1}\n" +
+                "5: CpuInfo{socketId=0, coreId=1, threadId=1}\n" +
+                "6: CpuInfo{socketId=0, coreId=2, threadId=1}\n" +
+                "7: CpuInfo{socketId=0, coreId=3, threadId=1}\n",
+                vcl.toString());
+    }
+}
+

From 64dabea6cff8a1ffc14b9b45d144c9b52b884e5a Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 15:04:38 +0100
Subject: [PATCH 29/53] Add unit test for affinity lock release

---
 .../affinity/AffinityLockReleaseTest.java     | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityLockReleaseTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockReleaseTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockReleaseTest.java
new file mode 100644
index 000000000..4cbc15f4d
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockReleaseTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2016-2025 chronicle.software
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.affinity;
+
+import net.openhft.affinity.impl.VanillaCpuLayout;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Unit test to verify that releasing an {@link AffinityLock} restores the
+ * affinity mask back to {@link AffinityLock#BASE_AFFINITY}.
+ */
+public class AffinityLockReleaseTest extends BaseAffinityTest {
+
+    @Test
+    public void acquireAndReleaseShouldRestoreBaseAffinity() throws Exception {
+        if (!new File("/proc/cpuinfo").exists()) {
+            System.out.println("Cannot run affinity test as this system doesn't have a /proc/cpuinfo file");
+            return;
+        }
+
+        // initialise CPU layout from the running machine so acquireLock works
+        AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo());
+
+        assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity());
+        AffinityLock lock = AffinityLock.acquireLock();
+        assertEquals(1, Affinity.getAffinity().cardinality());
+        lock.release();
+        assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity());
+    }
+}

From ad0ceacacb814c5fd0963b80b53120a59aea906a Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 16:17:45 +0100
Subject: [PATCH 30/53] Refactor LinuxHelper: change field modifiers from final
 to default for structure fields

---
 .../net/openhft/affinity/impl/LinuxHelper.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
index f5b5bdeb2..df5cbbc3d 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/LinuxHelper.java
@@ -183,7 +183,7 @@ int sched_getaffinity(final int pid,
     public static class utsname extends Structure {
         public static final int _UTSNAME_LENGTH = 65;
 
-        static final List<String> FIELD_ORDER = Arrays.asList(
+        static List<String> FIELD_ORDER = Arrays.asList(
                 "sysname",
                 "nodename",
                 "release",
@@ -195,32 +195,32 @@ public static class utsname extends Structure {
         /**
          * Name of the implementation of the operating system.
          */
-        public final byte[] sysname = new byte[_UTSNAME_LENGTH];
+        public byte[] sysname = new byte[_UTSNAME_LENGTH];
 
         /**
          * Name of this node on the network.
          */
-        public final byte[] nodename = new byte[_UTSNAME_LENGTH];
+        public byte[] nodename = new byte[_UTSNAME_LENGTH];
 
         /**
          * Current release level of this implementation.
          */
-        public final byte[] release = new byte[_UTSNAME_LENGTH];
+        public byte[] release = new byte[_UTSNAME_LENGTH];
 
         /**
          * Current version level of this release.
          */
-        public final byte[] version = new byte[_UTSNAME_LENGTH];
+        public byte[] version = new byte[_UTSNAME_LENGTH];
 
         /**
          * Name of the hardware type the system is running on.
          */
-        public final byte[] machine = new byte[_UTSNAME_LENGTH];
+        public byte[] machine = new byte[_UTSNAME_LENGTH];
 
         /**
          * NIS or YP domain name
          */
-        public final byte[] domainname = new byte[_UTSNAME_LENGTH];
+        public byte[] domainname = new byte[_UTSNAME_LENGTH];
 
         static int length(final byte[] data) {
             int len = 0;
@@ -286,8 +286,8 @@ public static class cpu_set_t extends Structure {
         static final int __CPU_SETSIZE = 1024;
         static final int __NCPUBITS = 8 * NativeLong.SIZE;
         static final int SIZE_OF_CPU_SET_T = (__CPU_SETSIZE / __NCPUBITS) * NativeLong.SIZE;
-        static final List<String> FIELD_ORDER = Collections.singletonList("__bits");
-        public final NativeLong[] __bits = new NativeLong[__CPU_SETSIZE / __NCPUBITS];
+        static List<String> FIELD_ORDER = Collections.singletonList("__bits");
+        public NativeLong[] __bits = new NativeLong[__CPU_SETSIZE / __NCPUBITS];
 
         public cpu_set_t() {
             for (int i = 0; i < __bits.length; i++) {

From 21fb1e2ff9cc498eeedd01ad9ee5fadfcd86cea5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 16:27:31 +0100
Subject: [PATCH 31/53] Add import for Utilities in LockCheck.java

---
 affinity/src/main/java/net/openhft/affinity/LockCheck.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/affinity/src/main/java/net/openhft/affinity/LockCheck.java b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
index dc4af7429..f75684552 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockCheck.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
@@ -17,6 +17,7 @@
 
 package net.openhft.affinity;
 
+import net.openhft.affinity.impl.Utilities;
 import net.openhft.affinity.lockchecker.FileLockBasedLockChecker;
 import net.openhft.affinity.lockchecker.LockChecker;
 import org.slf4j.Logger;

From 320d0bfabd962680ef5456a87a5392a3967991cc Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 22 May 2025 17:00:24 +0100
Subject: [PATCH 32/53] Enhance AffinityLock to support dual CPU IDs and update
 related methods

---
 .../net/openhft/affinity/AffinityLock.java    |  8 +++-
 .../java/net/openhft/affinity/CpuLayout.java  |  6 +++
 .../java/net/openhft/affinity/LockCheck.java  | 12 ++---
 .../net/openhft/affinity/LockInventory.java   | 10 ++--
 .../openhft/affinity/impl/NoCpuLayout.java    |  5 ++
 .../affinity/impl/VanillaCpuLayout.java       | 13 ++++++
 .../lockchecker/FileLockBasedLockChecker.java | 17 +++++--
 .../affinity/lockchecker/LockChecker.java     |  2 +-
 .../affinity/AffinityJNALoadFailureTest.java  | 46 -------------------
 .../openhft/affinity/AffinityLockTest.java    | 32 ++++++-------
 .../affinity/FileLockLockCheckTest.java       | 10 ++--
 .../net/openhft/affinity/LockCheckTest.java   |  8 ++--
 12 files changed, 81 insertions(+), 88 deletions(-)
 delete mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java

diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index 7f6fa5ece..3d28c4c86 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -69,6 +69,7 @@ public class AffinityLock implements Closeable {
      * Logical ID of the CPU to which this lock belongs to.
      */
     private final int cpuId;
+    private final int cpuId2;
     /**
      * CPU to which this lock belongs to is of general use.
      */
@@ -88,9 +89,10 @@ public class AffinityLock implements Closeable {
     Throwable boundHere;
     private boolean resetAffinity = true;
 
-    AffinityLock(int cpuId, boolean base, boolean reservable, LockInventory lockInventory) {
+    AffinityLock(int cpuId, int cpuId2, boolean base, boolean reservable, LockInventory lockInventory) {
         this.lockInventory = lockInventory;
         this.cpuId = cpuId;
+        this.cpuId2 = cpuId2;
         this.base = base;
         this.reservable = reservable;
     }
@@ -461,6 +463,10 @@ public int cpuId() {
         return cpuId;
     }
 
+    public int cpuId2() {
+        return cpuId2;
+    }
+
     /**
      * @return Was a cpu found to bind this lock to.
      */
diff --git a/affinity/src/main/java/net/openhft/affinity/CpuLayout.java b/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
index 7221d7dfb..12cbce61e 100644
--- a/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/CpuLayout.java
@@ -49,4 +49,10 @@ public interface CpuLayout {
      * @return which thread on a core this cpu is on.
      */
     int threadId(int cpuId);
+
+    /**
+     * @param cpuId the logical processor number
+     * @return the hyperthreaded pair number or 0 if not hyperthreaded.
+     */
+    int pair(int cpuId);
 }
diff --git a/affinity/src/main/java/net/openhft/affinity/LockCheck.java b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
index f75684552..5d3db1535 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockCheck.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
@@ -54,8 +54,8 @@ public static boolean isCpuFree(int cpu) {
         return isLockFree(cpu);
     }
 
-    static boolean replacePid(int cpu, long processID) throws IOException {
-        return storePid(processID, cpu);
+    static boolean replacePid(int cpu, int cpu2, long processID) throws IOException {
+        return storePid(processID, cpu, cpu2);
     }
 
     public static boolean isProcessRunning(long pid) {
@@ -69,8 +69,8 @@ public static boolean isProcessRunning(long pid) {
      * stores the pid in a file, named by the core, the pid is written to the file with the date
      * below
      */
-    private synchronized static boolean storePid(long processID, int cpu) throws IOException {
-        return lockChecker.obtainLock(cpu, Long.toString(processID));
+    private synchronized static boolean storePid(long processID, int cpu, int cpu2) throws IOException {
+        return lockChecker.obtainLock(cpu, cpu2, Long.toString(processID));
     }
 
     private synchronized static boolean isLockFree(int id) {
@@ -90,10 +90,10 @@ public static int getProcessForCpu(int core) throws IOException {
         return EMPTY_PID;
     }
 
-    static boolean updateCpu(int cpu) throws IOException {
+    static boolean updateCpu(int cpu, int cpu2) throws IOException {
         if (!canOSSupportOperation())
             return true;
-        return replacePid(cpu, getPID());
+        return replacePid(cpu, cpu2, getPID());
     }
 
     public static void releaseLock(int cpu) {
diff --git a/affinity/src/main/java/net/openhft/affinity/LockInventory.java b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
index 73bb7624c..0fa41b114 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockInventory.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockInventory.java
@@ -82,7 +82,7 @@ private static boolean isAnyCpu(final int cpuId) {
      */
     private static boolean updateLockForCurrentThread(final boolean bind, final AffinityLock al, final boolean wholeCore) throws ClosedByInterruptException {
         try {
-            if (LockCheck.updateCpu(al.cpuId())) {
+            if (LockCheck.updateCpu(al.cpuId(), wholeCore ? al.cpuId2() : 0)) {
                 al.assignCurrentThread(bind, wholeCore);
                 return true;
             }
@@ -110,7 +110,7 @@ public final synchronized void set(CpuLayout cpuLayout) {
             LOGGER.trace("cpu {} base={} reservable= {}", i, base, reservable);
             assert logicalCoreLocks != null;
             @SuppressWarnings("resource")
-            AffinityLock lock = logicalCoreLocks[i] = newLock(i, base, reservable);
+            AffinityLock lock = logicalCoreLocks[i] = newLock(i, cpuLayout.pair(i), base, reservable);
 
             int layoutId = lock.cpuId();
             int physicalCore = toPhysicalCore(layoutId);
@@ -279,8 +279,8 @@ public final synchronized String dumpLocks() {
         return dumpLocks(logicalCoreLocks);
     }
 
-    protected AffinityLock newLock(int cpuId, boolean base, boolean reservable) {
-        return new AffinityLock(cpuId, base, reservable, this);
+    protected AffinityLock newLock(int cpuId, int cpuId2, boolean base, boolean reservable) {
+        return new AffinityLock(cpuId, cpuId2, base, reservable, this);
     }
 
     private void reset(CpuLayout cpuLayout) {
@@ -303,6 +303,6 @@ private void releaseAffinityLock(final Thread t, final AffinityLock al, final St
     }
 
     public AffinityLock noLock() {
-        return newLock(AffinityLock.ANY_CPU, false, false);
+        return newLock(AffinityLock.ANY_CPU, 0, false, false);
     }
 }
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java b/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
index b22c36cf7..2996bdf0d 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/NoCpuLayout.java
@@ -64,4 +64,9 @@ public int coreId(int cpuId) {
     public int threadId(int cpuId) {
         return 0;
     }
+
+    @Override
+    public int pair(int cpuId) {
+        return 0;
+    }
 }
diff --git a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
index 7c17d1788..74ff2d580 100644
--- a/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
+++ b/affinity/src/main/java/net/openhft/affinity/impl/VanillaCpuLayout.java
@@ -177,6 +177,19 @@ public int threadId(int cpuId) {
         return cpuDetails.get(cpuId).threadId;
     }
 
+    @Override
+    public int pair(int cpuId) {
+        for (int i = 0; i < cpuDetails.size(); i++) {
+            CpuInfo info = cpuDetails.get(i);
+            if (info.socketId == cpuDetails.get(cpuId).socketId &&
+                    info.coreId == cpuDetails.get(cpuId).coreId &&
+                    info.threadId != cpuDetails.get(cpuId).threadId) {
+                return i;
+            }
+        }
+        return 0;
+    }
+
     @NotNull
     @Override
     public String toString() {
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
index 3551feab9..4da205991 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
@@ -98,14 +98,25 @@ public synchronized boolean isLockFree(int id) {
     }
 
     @Override
-    public synchronized boolean obtainLock(int id, String metaInfo) throws IOException {
+    public synchronized boolean obtainLock(int id, int id2, String metaInfo) throws IOException {
         int attempt = 0;
         while (attempt < MAX_LOCK_RETRIES) {
             try {
                 LockReference lockReference = tryAcquireLockOnFile(id, metaInfo);
                 if (lockReference != null) {
-                    locks[id] = lockReference;
-                    return true;
+                    if (id2 <= 0) {
+                        // no second lock to acquire, return success
+                        locks[id] = lockReference;
+                        return true;
+                    }
+                    LockReference lockReference2 = tryAcquireLockOnFile(id2, metaInfo);
+                    if (lockReference2 != null) {
+                        locks[id] = lockReference;
+                        locks[id2] = lockReference2;
+                        return true;
+                    } else {
+                        releaseLock(id);
+                    }
                 }
                 return false;
             } catch (ConcurrentLockFileDeletionException e) {
diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
index 8df4eafa1..62a6c2f52 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/LockChecker.java
@@ -26,7 +26,7 @@ public interface LockChecker {
 
     boolean isLockFree(int id);
 
-    boolean obtainLock(int id, String metaInfo) throws IOException;
+    boolean obtainLock(int id, int id2, String metaInfo) throws IOException;
 
     boolean releaseLock(int id);
 
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java
deleted file mode 100644
index 92b89b153..000000000
--- a/affinity/src/test/java/net/openhft/affinity/AffinityJNALoadFailureTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-import org.junit.Test;
-
-import java.io.File;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.assertSame;
-
-public class AffinityJNALoadFailureTest {
-
-    @Test
-    public void shouldReturnNullAffinityWhenJnaFailsToLoad() throws Exception {
-        // Build URLs from current classpath
-        String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
-        List<URL> urlList = new ArrayList<>();
-        for (String p : cp) {
-            urlList.add(new File(p).toURI().toURL());
-        }
-        URLClassLoader cl = new URLClassLoader(urlList.toArray(new URL[0]), null);
-
-        // Force JNA version < 5 in the new classloader
-        Class<?> nativeCls = Class.forName("com.sun.jna.Native", true, cl);
-        Field verField = nativeCls.getDeclaredField("VERSION");
-        verField.setAccessible(true);
-        Field modField = Field.class.getDeclaredField("modifiers");
-        modField.setAccessible(true);
-        modField.setInt(verField, verField.getModifiers() & ~Modifier.FINAL);
-        Object originalVer = verField.get(null);
-        verField.set(null, "4.0.0");
-        try {
-            Class<?> affinityCls = Class.forName("net.openhft.affinity.Affinity", true, cl);
-            Method m = affinityCls.getMethod("getAffinityImpl");
-            Object impl = m.invoke(null);
-            Class<?> nullAffinityCls = Class.forName("net.openhft.affinity.impl.NullAffinity", true, cl);
-            Object expected = nullAffinityCls.getEnumConstants()[0];
-            assertSame(expected, impl);
-        } finally {
-            verField.set(null, originalVer);
-        }
-    }
-}
diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index ef01d14a4..939f58552 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -20,8 +20,6 @@
 import net.openhft.affinity.impl.Utilities;
 import net.openhft.affinity.impl.VanillaCpuLayout;
 import net.openhft.affinity.testimpl.TestFileLockBasedLockChecker;
-import net.openhft.affinity.CpuLayout;
-import net.openhft.affinity.LockCheck;
 import org.hamcrest.MatcherAssert;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -51,14 +49,14 @@ public class AffinityLockTest extends BaseAffinityTest {
     public void dumpLocksI7() throws IOException {
         LockInventory lockInventory = new LockInventory(VanillaCpuLayout.fromCpuInfo("i7.cpuinfo"));
         AffinityLock[] locks = {
-                new AffinityLock(0, true, false, lockInventory),
-                new AffinityLock(1, false, false, lockInventory),
-                new AffinityLock(2, false, true, lockInventory),
-                new AffinityLock(3, false, true, lockInventory),
-                new AffinityLock(4, true, false, lockInventory),
-                new AffinityLock(5, false, false, lockInventory),
-                new AffinityLock(6, false, true, lockInventory),
-                new AffinityLock(7, false, true, lockInventory),
+                new AffinityLock(0, 0, true, false, lockInventory),
+                new AffinityLock(1, 5, false, false, lockInventory),
+                new AffinityLock(2, 6, false, true, lockInventory),
+                new AffinityLock(3, 7, false, true, lockInventory),
+                new AffinityLock(4, 0, true, false, lockInventory),
+                new AffinityLock(5, 1, false, false, lockInventory),
+                new AffinityLock(6, 2, false, true, lockInventory),
+                new AffinityLock(7, 3, false, true, lockInventory),
         };
         locks[2].assignedThread = new Thread(new InterrupedThread(), "logger");
         locks[2].assignedThread.start();
@@ -88,10 +86,10 @@ public void dumpLocksI7() throws IOException {
     public void dumpLocksI3() throws IOException {
         LockInventory lockInventory = new LockInventory(VanillaCpuLayout.fromCpuInfo("i3.cpuinfo"));
         AffinityLock[] locks = {
-                new AffinityLock(0, true, false, lockInventory),
-                new AffinityLock(1, false, true, lockInventory),
-                new AffinityLock(2, true, false, lockInventory),
-                new AffinityLock(3, false, true, lockInventory),
+                new AffinityLock(0, 0,true, false, lockInventory),
+                new AffinityLock(1, 3, false, true, lockInventory),
+                new AffinityLock(2, 0, true, false, lockInventory),
+                new AffinityLock(3, 1, false, true, lockInventory),
         };
         locks[1].assignedThread = new Thread(new InterrupedThread(), "engine");
         locks[1].assignedThread.start();
@@ -111,8 +109,8 @@ public void dumpLocksI3() throws IOException {
     public void dumpLocksCoreDuo() throws IOException {
         LockInventory lockInventory = new LockInventory(VanillaCpuLayout.fromCpuInfo("core.duo.cpuinfo"));
         AffinityLock[] locks = {
-                new AffinityLock(0, true, false, lockInventory),
-                new AffinityLock(1, false, true, lockInventory),
+                new AffinityLock(0, 0,true, false, lockInventory),
+                new AffinityLock(1, 0,false, true, lockInventory),
         };
         locks[1].assignedThread = new Thread(new InterrupedThread(), "engine");
         locks[1].assignedThread.start();
@@ -328,7 +326,7 @@ public void testTooHighCpuId() {
 
     @Test(expected = IllegalArgumentException.class)
     public void testTooHighCpuId2() {
-        AffinityLock.acquireLock(new int[] {123456});
+        AffinityLock.acquireLock(new int[]{123456});
     }
 
     @Test(expected = IllegalStateException.class)
diff --git a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
index 9f6ffd247..b155e4999 100644
--- a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
@@ -45,7 +45,7 @@ public void before() {
     @Test
     public void test() throws IOException {
         Assert.assertTrue(LockCheck.isCpuFree(cpu));
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
         Assert.assertEquals(LockCheck.getPID(), LockCheck.getProcessForCpu(cpu));
     }
 
@@ -58,13 +58,13 @@ public void testPidOnLinux() {
     public void testReplace() throws IOException {
         cpu++;
         Assert.assertTrue(LockCheck.isCpuFree(cpu + 1));
-        LockCheck.replacePid(cpu, 123L);
+        LockCheck.replacePid(cpu, 0, 123L);
         Assert.assertEquals(123L, LockCheck.getProcessForCpu(cpu));
     }
 
     @Test
     public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception {
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
 
         final File file = lockChecker.doToFile(cpu);
         new RandomAccessFile(file, "rw").setLength(0);
@@ -77,7 +77,7 @@ public void lockFileDeletedWhileHeld() throws Exception {
         cpu++;
 
         Assert.assertTrue(LockCheck.isCpuFree(cpu));
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
 
         File lockFile = lockChecker.doToFile(cpu);
         Assert.assertTrue(lockFile.exists());
@@ -91,7 +91,7 @@ public void lockFileDeletedWhileHeld() throws Exception {
         LockCheck.releaseLock(cpu);
 
         Assert.assertTrue("Lock should be free after release", LockCheck.isCpuFree(cpu));
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
 
         lockFile = lockChecker.doToFile(cpu);
         Assert.assertTrue("Lock file should be recreated", lockFile.exists());
diff --git a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
index c7f04465b..40f5d18e5 100644
--- a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
@@ -46,7 +46,7 @@ public void before() {
     @Test
     public void test() throws IOException {
         Assert.assertTrue(LockCheck.isCpuFree(cpu));
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
         Assert.assertEquals(LockCheck.getPID(), LockCheck.getProcessForCpu(cpu));
     }
 
@@ -59,13 +59,13 @@ public void testPidOnLinux() {
     public void testReplace() throws IOException {
         cpu++;
         Assert.assertTrue(LockCheck.isCpuFree(cpu + 1));
-        LockCheck.replacePid(cpu, 123L);
+        LockCheck.replacePid(cpu, 0, 123L);
         Assert.assertEquals(123L, LockCheck.getProcessForCpu(cpu));
     }
 
     @Test
     public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception {
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
 
         final File file = lockChecker.doToFile(cpu);
         new RandomAccessFile(file, "rw").setLength(0);
@@ -75,7 +75,7 @@ public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception {
 
     @Test
     public void shouldNotBlowUpIfPidFileIsCorrupt() throws Exception {
-        LockCheck.updateCpu(cpu);
+        LockCheck.updateCpu(cpu, 0);
 
         final File file = lockChecker.doToFile(cpu);
         try (final FileWriter writer = new FileWriter(file, false)) {

From 4f0685a7d330cfb346e27de316e71d2c4ce3a9a5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 08:42:55 +0100
Subject: [PATCH 33/53] Add requirements document for Java Thread Affinity
 library

---
 affinity/src/main/adoc/requirements.adoc | 297 +++++++++++++++++++++++
 1 file changed, 297 insertions(+)
 create mode 100644 affinity/src/main/adoc/requirements.adoc

diff --git a/affinity/src/main/adoc/requirements.adoc b/affinity/src/main/adoc/requirements.adoc
new file mode 100644
index 000000000..f15cf0ed4
--- /dev/null
+++ b/affinity/src/main/adoc/requirements.adoc
@@ -0,0 +1,297 @@
+= Requirements Document: Java Thread Affinity
+Author: Gemini AI
+Date: 23 May 2025
+Version: 1.0
+:toc: left
+:toclevels: 3
+:sectnums:
+
+== 1. Introduction
+
+This document outlines the requirements for the *Java Thread Affinity* library. The primary purpose of this library is to provide Java applications with the capability to control Central Processing Unit (CPU) affinity for their threads. This allows developers to bind specific threads to designated CPU cores, which can lead to performance improvements, especially in latency-sensitive applications, by reducing context switching and improving cache utilisation.
+
+The library aims to offer a cross-platform API, with the most comprehensive support for Linux systems, leveraging Java Native Access (JNA) and, where applicable, Java Native Interface (JNI) for low-level system interactions.
+
+== 2. Scope
+
+The scope of the Java Thread Affinity project includes:
+
+* Providing mechanisms to get and set thread affinity on supported operating systems.
+* Offering a CPU locking mechanism (`AffinityLock`) to manage core reservations for threads or entire cores.
+* Detecting or allowing specification of the CPU layout (sockets, cores, threads per core).
+* Providing a high-resolution timer.
+* Supporting inter-process lock checking for CPU core reservations.
+* Delivering a thread factory that assigns affinity to newly created threads.
+* Packaging the core library and an OSGi-compatible test bundle.
+
+== 3. Definitions, Acronyms, and Abbreviations
+
+* *CPU*: Central Processing Unit
+* *JNA*: Java Native Access
+* *JNI*: Java Native Interface
+* *OS*: Operating System
+* *PID*: Process Identifier
+* *OSGi*: Open Service Gateway initiative
+* *POM*: Project Object Model (Maven)
+* *API*: Application Programming Interface
+
+== 4. References
+
+* Project Repository: https://github.com/OpenHFT/Java-Thread-Affinity
+* JNA: https://github.com/java-native-access/jna
+
+== 5. Project Overview
+
+The *Java Thread Affinity* library enables fine-grained control over which CPU cores Java threads execute on. This is particularly beneficial for high-performance computing and low-latency applications where minimising jitter and maximising cache efficiency is critical. The library abstracts OS-specific details, providing a unified Java API.
+
+=== 5.1. Purpose
+
+* To allow Java threads to be bound to specific CPU cores.
+* To provide tools for understanding and managing CPU topology from within a Java application.
+* To offer a high-resolution timing mechanism.
+
+=== 5.2. Benefits
+
+* _Performance Improvement_: Reduced thread migration and context switching.
+* _Cache Efficiency_: Better utilisation of CPU caches (L1, L2, L3).
+* _Jitter Reduction_: More predictable thread execution times.
+
+== 6. Functional Requirements
+
+=== 6.1. Core Affinity Control (net.openhft.affinity.Affinity)
+
+* *FR1*: The system _shall_ allow setting the affinity of the current thread to a specific CPU core or a set of cores (BitSet).
+** `Affinity.setAffinity(BitSet affinity)`
+** `Affinity.setAffinity(int cpu)`
+* *FR2*: The system _shall_ allow retrieving the current affinity mask of the current thread.
+** `Affinity.getAffinity()`
+* *FR3*: The system _shall_ allow querying the logical CPU ID the current thread is running on.
+** `Affinity.getCpu()`
+* *FR4*: The system _shall_ allow retrieving the native process ID of the current Java process.
+** `IAffinity.getProcessId()`
+* *FR5*: The system _shall_ allow retrieving the native thread ID of the current Java thread.
+** `IAffinity.getThreadId()`
+** `Affinity.setThreadId()` (to update `Thread.tid` via reflection if available)
+
+=== 6.2. CPU Lock Management (net.openhft.affinity.AffinityLock)
+
+* *FR6.1*: The system _shall_ provide a mechanism to acquire an exclusive lock on an available CPU core for the current thread.
+** `AffinityLock.acquireLock()`
+** `AffinityLock.acquireLock(boolean bind)`
+** `AffinityLock.acquireLock(int cpuId)`
+** `AffinityLock.acquireLock(String desc)` (e.g., "last", "last-N", "N", "any", "none", "csv:1,2,3")
+* *FR6.2*: The system _shall_ provide a mechanism to acquire an exclusive lock on an entire physical core (including all its logical CPUs/hyper-threads).
+** `AffinityLock.acquireCore()`
+** `AffinityLock.acquireCore(boolean bind)`
+* *FR6.3*: Acquired locks _shall_ be releasable, restoring the thread's affinity to a base state or a defined default.
+** `AffinityLock.release()`
+** `AffinityLock.close()` (for try-with-resources)
+* *FR6.4*: The system _shall_ support affinity strategies for acquiring new locks relative to existing locks (e.g., same core, same socket, different core, different socket).
+** `AffinityLock.acquireLock(AffinityStrategy... strategies)`
+** `AffinityStrategies` enum: `ANY`, `SAME_CORE`, `SAME_SOCKET`, `DIFFERENT_CORE`, `DIFFERENT_SOCKET`.
+* *FR6.5*: The system _shall_ provide a method to dump the current status of all CPU locks managed by the library.
+** `AffinityLock.dumpLocks()`
+* *FR6.6*: The system _shall_ allow querying if a lock is allocated and bound.
+** `AffinityLock.isAllocated()`
+** `AffinityLock.isBound()`
+
+=== 6.3. CPU Layout Detection (net.openhft.affinity.CpuLayout)
+
+* *FR7.1*: On Linux, the system _shall_ attempt to automatically detect the CPU layout (sockets, cores per socket, threads per core) by parsing `/proc/cpuinfo`.
+** `VanillaCpuLayout.fromCpuInfo()`
+* *FR7.2*: The system _shall_ allow applications to programmatically define the CPU layout.
+** `AffinityLock.cpuLayout(CpuLayout cpuLayout)`
+* *FR7.3*: The CPU layout _shall_ provide information about:
+** Total number of logical CPUs: `CpuLayout.cpus()`
+** Number of sockets: `CpuLayout.sockets()`
+** Cores per socket: `CpuLayout.coresPerSocket()`
+** Threads per core: `CpuLayout.threadsPerCore()`
+** Mapping a logical CPU ID to its socket, core, and thread ID: `socketId(int)`, `coreId(int)`, `threadId(int)`.
+** Hyper-threaded pair for a CPU: `pair(int)`.
+
+=== 6.4. High-Resolution Timer (net.openhft.ticker.Ticker)
+
+* *FR8.1*: The system _shall_ provide a high-resolution time source.
+** `Ticker.ticks()` (raw timer ticks)
+** `Ticker.nanoTime()` (ticks converted to nanoseconds)
+* *FR8.2*: If native JNI components are available and loaded (specifically `libCEInternals.so`), the timer _shall_ attempt to use `rdtsc` (Read Time-Stamp Counter).
+** `JNIClock.rdtsc0()`
+* *FR8.3*: If JNI-based `rdtsc` is not available, the timer _shall_ fall back to `System.nanoTime()`.
+** `SystemClock.INSTANCE`
+* *FR8.4*: The timer _shall_ provide methods to convert ticks to nanoseconds and microseconds.
+** `ITicker.toNanos(long ticks)`
+** `ITicker.toMicros(double ticks)`
+
+=== 6.5. OS-Specific Implementations (net.openhft.affinity.impl)
+
+* *FR9.1*: The system _shall_ provide tailored implementations of `IAffinity` for different operating systems:
+** *Linux*: Full affinity control, CPU ID, Process ID, Thread ID via JNA (`LinuxJNAAffinity`, `PosixJNAAffinity`) or JNI (`NativeAffinity`).
+** *Windows*: Thread affinity control, Process ID, Thread ID via JNA (`WindowsJNAAffinity`). `getCpu()` returns -1.
+** *macOS*: Process ID, Thread ID via JNA (`OSXJNAAffinity`). No affinity modification; `getCpu()` returns -1.
+** *Solaris*: Process ID, Thread ID via JNA (`SolarisJNAAffinity`). No affinity modification; `getCpu()` returns -1.
+* *FR9.2*: A `NullAffinity` implementation _shall_ be used as a fallback if no suitable native implementation can be loaded or for unsupported OS.
+
+=== 6.6. Affinity Thread Factory (net.openhft.affinity.AffinityThreadFactory)
+
+* *FR10.1*: The system _shall_ provide a `ThreadFactory` that assigns affinity to newly created threads based on specified `AffinityStrategy` rules.
+** `new AffinityThreadFactory(String name, AffinityStrategy... strategies)`
+* *FR10.2*: If no strategies are provided, `AffinityStrategies.ANY` _shall_ be used by default.
+
+=== 6.7. Inter-Process Lock Checking (net.openhft.affinity.lockchecker)
+
+* *FR11.1*: On Linux, the system _shall_ provide a mechanism to check if a specific CPU core is free or already locked by another process.
+** `LockCheck.isCpuFree(int cpu)`
+* *FR11.2*: This mechanism _shall_ use file-based locks located in the directory specified by the `java.io.tmpdir` system property.
+** `FileLockBasedLockChecker`
+* *FR11.3*: The system _shall_ allow obtaining and releasing these inter-process locks for specified CPU IDs.
+** `LockChecker.obtainLock(int id, int id2, String metaInfo)`
+** `LockChecker.releaseLock(int id)`
+* *FR11.4*: The system _shall_ store meta-information (e.g., PID of the locking process) within the lock file and allow its retrieval.
+** `LockChecker.getMetaInfo(int id)`
+
+=== 6.8. Native Code Compilation (C/C++)
+
+* *FR12.1*: The system _shall_ include C/C++ source code for native functions required for affinity and timer operations on Linux and macOS.
+    ** `software_chronicle_enterprise_internals_impl_NativeAffinity.cpp` (Linux)
+    ** `software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c` (macOS)
+    ** `net_openhft_ticker_impl_JNIClock.cpp` (for `rdtsc`)
+* *FR12.2*: A Makefile _shall_ be provided to compile the native C/C++ code into a shared library (`libCEInternals.so`).
+* *FR12.3*: The Java code _shall_ load this native library if available.
+** `software.chronicle.enterprise.internals.impl.NativeAffinity.loadAffinityNativeLibrary()`
+
+== 7. Non-Functional Requirements
+
+* *NFR1. Platform Support*:
+** *Primary Support*: Linux (full functionality).
+** *Partial Support*: Windows (affinity setting, PID/TID, no `getCpu()`).
+** *Limited Support*: macOS, Solaris (PID/TID only, no affinity setting or `getCpu()`).
+* *NFR2. Dependencies*:
+** *JNA*: `net.java.dev.jna:jna`, `net.java.dev.jna:jna-platform`. Version 5.x or higher is recommended for full functionality. The project currently uses version 4.4.0 (as per README, though POMs might show updates).
+** *SLF4J API*: `org.slf4j:slf4j-api` for logging.
+** *JetBrains Annotations*: `org.jetbrains:annotations` for code quality.
+* *NFR3. Performance*: The library _should_ introduce minimal overhead. Native calls _should_ be efficient. The primary goal is to enable performance improvements in the client application.
+* *NFR4. Licensing*: The project _shall_ be licensed under the Apache License, Version 2.0.
+* *NFR5. Build System*: The project _shall_ use Apache Maven for building and dependency management.
+* *NFR6. Language*:
+** Core library _shall_ be implemented in Java (1.8+ as per POM).
+** Native components _shall_ be implemented in C/C++.
+* *NFR7. Usability*:
+** The API _should_ be clear and relatively simple to use.
+** Javadoc _shall_ be provided for public APIs.
+** Example usage _shall_ be available (e.g., in test sources and README).
+* *NFR8. Error Handling and Resilience*:
+** The library _shall_ degrade gracefully if JNA or native libraries are not available or if an OS does not support certain features (e.g., falling back to `NullAffinity`).
+** Errors during native calls _should_ be appropriately logged and/or propagated as exceptions.
+* *NFR9. Configuration*:
+** Reserved CPUs for the application _shall_ be configurable via the system property `affinity.reserved={hex-mask}`.
+** The lock file directory _shall_ default to `java.io.tmpdir` and be overridable by setting this system property.
+* *NFR10. OSGi Support*: The `affinity-test` module _shall_ be packaged as an OSGi bundle, demonstrating OSGi compatibility.
+* *NFR11. Language Style*: Code and documentation _shall_ use British English, except for established technical US spellings (e.g., `synchronized`).
+
+== 8. System Architecture
+
+=== 8.1. High-Level Architecture
+
+The Java Thread Affinity library is a Java-based system that interfaces with the underlying operating system through JNA (primarily) and JNI (for specific `libCEInternals.so` functionalities). It abstracts OS-specific system calls related to thread affinity, CPU information, and timing.
+
+=== 8.2. Key Components
+
+* *`net.openhft.affinity.Affinity`*: Main public API facade for basic affinity operations.
+* *`net.openhft.affinity.IAffinity`*: Interface defining the contract for OS-specific implementations.
+** Concrete Implementations: `LinuxJNAAffinity`, `WindowsJNAAffinity`, `OSXJNAAffinity`, `SolarisJNAAffinity`, `PosixJNAAffinity`, `NativeAffinity` (JNI), `NullAffinity`.
+* *`net.openhft.affinity.AffinityLock`*: Manages CPU reservations and bindings.
+* *`net.openhft.affinity.LockInventory`*: Tracks the state of CPU locks based on `CpuLayout`.
+* *`net.openhft.affinity.CpuLayout`*: Interface for CPU topology information.
+** `VanillaCpuLayout`: Parses `/proc/cpuinfo` or properties files.
+** `NoCpuLayout`: Default layout if detection fails.
+* *`net.openhft.affinity.AffinityStrategies`*: Enum defining strategies for selecting CPUs.
+* *`net.openhft.affinity.AffinityThreadFactory`*: A `java.util.concurrent.ThreadFactory` that sets affinity for new threads.
+* *`net.openhft.ticker.Ticker`*: Provides high-resolution time.
+** `JNIClock`: Uses `rdtsc` via JNI.
+** `SystemClock`: Uses `System.nanoTime()`.
+* *`net.openhft.affinity.lockchecker.LockChecker`*: Interface for inter-process lock management.
+** `FileLockBasedLockChecker`: Implementation using file system locks.
+* *Native Code (`src/main/c`)*: C/C++ sources for `libCEInternals.so` providing functions like `getAffinity0`, `setAffinity0` (Linux JNI), `rdtsc0`.
+
+=== 8.3. Maven Modules
+
+* *`Java-Thread-Affinity` (Parent POM)*: Aggregates sub-modules.
+** Group ID: `net.openhft`
+** Artifact ID: `Java-Thread-Affinity`
+* *`affinity` (Core Library)*: Contains the main library code, JNA/JNI integrations, and native sources.
+** Artifact ID: `affinity`
+** Packaging: `bundle` (OSGi compatible)
+* *`affinity-test` (Test Module)*: Contains OSGi integration tests and example usage.
+** Artifact ID: `affinity-test`
+** Packaging: `bundle`
+
+== 9. Native Components (libCEInternals.so)
+
+The library can utilise an optional native shared library, `libCEInternals.so`, for certain operations, primarily on Linux.
+
+* *Purpose*: Provides direct JNI implementations for thread affinity and the `rdtsc` timer.
+* *Source Location*: `Java-Thread-Affinity/affinity/src/main/c/`
+* *Build*: Compiled using the `Makefile` in the source directory (typically invoked by Maven's `exec-maven-plugin`).
+* *Key Native Functions Implemented*:
+** `Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getAffinity0`
+** `Java_software_chronicle_enterprise_internals_impl_NativeAffinity_setAffinity0`
+** `Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getCpu0`
+** `Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getProcessId0`
+** `Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getThreadId0`
+** `Java_net_openhft_ticker_impl_JNIClock_rdtsc0`
+* *Platform Specifics*:
+** *Linux*: Uses `sched_getaffinity`, `sched_setaffinity`, `sched_getcpu`, `getpid`, `syscall(SYS_gettid)`.
+** *macOS*: (Separate C file `software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c`) Uses `pthread_mach_thread_np`, `thread_policy_get`, `thread_policy_set`. Note: JNA implementations are generally preferred on macOS.
+* *Loading*: The `NativeAffinity.java` class attempts to load `System.loadLibrary("CEInternals")`.
+
+== 10. API Overview
+
+A brief overview of the primary public classes and interfaces:
+
+* *`net.openhft.affinity.Affinity`*:
+** Static utility methods for basic affinity operations: `getAffinity()`, `setAffinity(BitSet)`, `setAffinity(int cpu)`, `getCpu()`, `getThreadId()`.
+** Manages selection of the appropriate `IAffinity` implementation.
+* *`net.openhft.affinity.AffinityLock`*:
+** Manages acquisition and release of CPU locks: `acquireLock()`, `acquireCore()`, `release()`, `close()`.
+** Configures CPU layout: `cpuLayout(CpuLayout)`.
+** Provides information about reserved CPUs: `BASE_AFFINITY`, `RESERVED_AFFINITY`.
+* *`net.openhft.affinity.AffinityStrategies`*:
+** Enum defining CPU selection strategies for `AffinityLock`.
+* *`net.openhft.affinity.CpuLayout`*:
+** Interface to describe the machine's CPU topology.
+* *`net.openhft.affinity.IAffinity`*:
+** Core interface implemented by OS-specific providers.
+* *`net.openhft.ticker.Ticker`*:
+** Static utility for accessing high-resolution time: `ticks()`, `nanoTime()`.
+* *`net.openhft.affinity.AffinityThreadFactory`*:
+** Implements `java.util.concurrent.ThreadFactory` to create threads with specific affinity settings.
+
+== 11. Build and Deployment
+
+* The project is built using Apache Maven.
+* The main artifact `net.openhft:affinity` is an OSGi bundle.
+* Dependencies are managed via `pom.xml` files, including a `third-party-bom` and `chronicle-bom`.
+* The `make-c` profile in `affinity/pom.xml` triggers the compilation of native C code using `make`.
+* The `maven-bundle-plugin` is used to generate OSGi manifest information.
+* The `maven-scm-publish-plugin` is configured for publishing Javadoc to `gh-pages`.
+
+== 12. Testing
+
+The project includes a comprehensive suite of tests:
+
+* *Unit Tests*: Located in `affinity/src/test/java/`.
+** `NativeAffinityTest`, `JnaAffinityTest`: Test core JNI/JNA functionalities.
+** `AffinityLockTest`: Tests `AffinityLock` logic, including descriptions and inter-thread lock acquisition.
+** `VanillaCpuLayoutTest`, `VanillaCpuLayoutPropertiesParseTest`: Test parsing of `cpuinfo` files and properties files for CPU layout.
+** `TickerTest`, `JNIClockTest`: Test timer implementations.
+** `LockCheckTest`, `FileLockLockCheckTest`: Test inter-process lock checking.
+** `MultiProcessAffinityTest`: Tests affinity locking behavior across multiple Java processes.
+* *OSGi Bundle Tests*: Located in `affinity-test/src/test/java/net/openhft/affinity/osgi/`.
+** `OSGiBundleTest`: Verifies bundle activation and package exports in an OSGi environment using Pax Exam.
+* *Test Resources*: Includes sample `cpuinfo` files for various architectures and corresponding properties files to test layout parsing.
+** `affinity/src/test/resources/`
+* *Test Infrastructure*:
+** `BaseAffinityTest`: Provides common setup for tests, including temporary folder management for lock files.
+** `chronicle-test-framework`: Used for some test utilities, like `JavaProcessBuilder` for multi-process tests.
+
+The tests cover various aspects including basic affinity setting, CPU layout parsing, lock management, multi-threading scenarios, multi-process contention, and OSGi integration.

From 3a225dd29d1cd40c264d40ff012d718e1c62987d Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:03:37 +0100
Subject: [PATCH 34/53] Add test for setThreadId reflection update

---
 .../net/openhft/affinity/SetThreadIdTest.java | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/SetThreadIdTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/SetThreadIdTest.java b/affinity/src/test/java/net/openhft/affinity/SetThreadIdTest.java
new file mode 100644
index 000000000..aa6c1caf1
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/SetThreadIdTest.java
@@ -0,0 +1,25 @@
+package net.openhft.affinity;
+
+import org.junit.Assume;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.assertEquals;
+
+public class SetThreadIdTest {
+
+    @Test
+    public void setThreadIdShouldUpdateThreadTidField() throws Exception {
+        Field tidFieldField = Affinity.class.getDeclaredField("THREAD_TID_FIELD");
+        tidFieldField.setAccessible(true);
+        Field tidField = (Field) tidFieldField.get(null);
+        Assume.assumeTrue(tidField != null);
+        tidField.setAccessible(true);
+
+        Affinity.setThreadId();
+        long expected = Affinity.getThreadId();
+        long actual = tidField.getLong(Thread.currentThread());
+        assertEquals(expected, actual);
+    }
+}

From f5b3e76dc5b3e361812f931c637caa4aeae11fc1 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:03:47 +0100
Subject: [PATCH 35/53] Add test for resetting affinity

---
 .../AffinityResetToBaseAffinityTest.java      | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityResetToBaseAffinityTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityResetToBaseAffinityTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityResetToBaseAffinityTest.java
new file mode 100644
index 000000000..502cb0e0b
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityResetToBaseAffinityTest.java
@@ -0,0 +1,33 @@
+package net.openhft.affinity;
+
+import net.openhft.affinity.impl.VanillaCpuLayout;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class AffinityResetToBaseAffinityTest extends BaseAffinityTest {
+
+    @Test
+    public void resettingShouldRestoreBaseAffinity() throws Exception {
+        if (!new File("/proc/cpuinfo").exists()) {
+            System.out.println("Cannot run affinity test as this system doesn't have a /proc/cpuinfo file");
+            return;
+        }
+
+        // initialise CPU layout from the running machine so acquireLock works
+        AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo());
+
+        assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity());
+        AffinityLock lock = AffinityLock.acquireLock();
+        try {
+            assertEquals(1, Affinity.getAffinity().cardinality());
+
+            Affinity.resetToBaseAffinity();
+            assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity());
+        } finally {
+            lock.release();
+        }
+    }
+}

From 3e8ed8e6055b53dcecf62833d373b0688e2ddeb6 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:06:07 +0100
Subject: [PATCH 36/53] test: ensure bind false leaves affinity unchanged

---
 .../java/net/openhft/affinity/AffinityLockTest.java   | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 939f58552..352f1ee43 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -31,6 +31,7 @@
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.BitSet;
 
 import static net.openhft.affinity.AffinityLock.PROCESSORS;
 import static org.hamcrest.CoreMatchers.is;
@@ -319,6 +320,16 @@ public void testAffinityLockDescriptions() {
         }
     }
 
+    @Test
+    public void acquireLockWithoutBindingDoesNotChangeAffinity() {
+        BitSet before = (BitSet) Affinity.getAffinity().clone();
+        try (AffinityLock lock = AffinityLock.acquireLock(false)) {
+            assertFalse(lock.isBound());
+            assertEquals(before, Affinity.getAffinity());
+        }
+        assertEquals(before, Affinity.getAffinity());
+    }
+
     @Test(expected = IllegalArgumentException.class)
     public void testTooHighCpuId() {
         AffinityLock.acquireLock(123456);

From 2507f81cd8a7d3c17f1e2d9c91c7ada0ccae7682 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:06:19 +0100
Subject: [PATCH 37/53] Add test for negative cpu id

---
 .../src/test/java/net/openhft/affinity/AffinityLockTest.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 939f58552..d0187b48a 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -324,6 +324,11 @@ public void testTooHighCpuId() {
         AffinityLock.acquireLock(123456);
     }
 
+    @Test(expected = IllegalArgumentException.class)
+    public void testNegativeCpuId() {
+        AffinityLock.acquireLock(-1);
+    }
+
     @Test(expected = IllegalArgumentException.class)
     public void testTooHighCpuId2() {
         AffinityLock.acquireLock(new int[]{123456});

From 9badab6bbb5fdcfc191306ebb8e597dfaa218aa2 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:06:54 +0100
Subject: [PATCH 38/53] Verify lock file removal after release

---
 .../test/java/net/openhft/affinity/AffinityLockTest.java  | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 939f58552..e95e6fc98 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -19,7 +19,6 @@
 
 import net.openhft.affinity.impl.Utilities;
 import net.openhft.affinity.impl.VanillaCpuLayout;
-import net.openhft.affinity.testimpl.TestFileLockBasedLockChecker;
 import org.hamcrest.MatcherAssert;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -28,6 +27,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
@@ -43,7 +43,6 @@
 public class AffinityLockTest extends BaseAffinityTest {
     private static final Logger logger = LoggerFactory.getLogger(AffinityLockTest.class);
 
-    private final TestFileLockBasedLockChecker lockChecker = new TestFileLockBasedLockChecker();
 
     @Test
     public void dumpLocksI7() throws IOException {
@@ -254,11 +253,12 @@ public void lockFilesShouldBeRemovedOnRelease() {
         }
         final AffinityLock lock = AffinityLock.acquireLock();
 
-        assertTrue(Files.exists(Paths.get(lockChecker.doToFile(lock.cpuId()).getAbsolutePath())));
+        Path lockFile = Paths.get(System.getProperty("java.io.tmpdir"), "cpu-" + lock.cpuId() + ".lock");
+        assertTrue(Files.exists(lockFile));
 
         lock.release();
 
-        assertFalse(Files.exists(Paths.get(lockChecker.doToFile(lock.cpuId()).getAbsolutePath())));
+        assertFalse(Files.exists(lockFile));
     }
 
     @Test

From 80085d190e137215b62252e5f883a10a51963353 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:07:50 +0100
Subject: [PATCH 39/53] Add test for dumpLocks across threads

---
 .../affinity/AffinityLockDumpLocksTest.java   | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
new file mode 100644
index 000000000..00aa020b2
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
@@ -0,0 +1,54 @@
+package net.openhft.affinity;
+
+import net.openhft.affinity.impl.VanillaCpuLayout;
+import org.junit.Assume;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertTrue;
+
+public class AffinityLockDumpLocksTest extends BaseAffinityTest {
+
+    @Test
+    public void dumpLocksListsThreadsHoldingLocks() throws Exception {
+        Assume.assumeTrue(new File("/proc/cpuinfo").exists());
+
+        AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo());
+
+        int nThreads = Math.min(3, Math.max(1, AffinityLock.PROCESSORS - 1));
+        CountDownLatch acquired = new CountDownLatch(nThreads);
+        CountDownLatch release = new CountDownLatch(1);
+        List<Thread> threads = new ArrayList<>();
+
+        for (int i = 0; i < nThreads; i++) {
+            String name = "worker-" + i;
+            Thread t = new Thread(() -> {
+                try (AffinityLock lock = AffinityLock.acquireLock()) {
+                    acquired.countDown();
+                    release.await();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }, name);
+            threads.add(t);
+            t.start();
+        }
+
+        assertTrue("threads failed to acquire locks", acquired.await(5, TimeUnit.SECONDS));
+
+        String dump = AffinityLock.dumpLocks();
+        for (Thread t : threads) {
+            assertTrue("Missing entry for " + t.getName(), dump.contains("Thread[" + t.getName()));
+        }
+
+        release.countDown();
+        for (Thread t : threads) {
+            t.join();
+        }
+    }
+}

From 310a0da8c9e36562c6d6779b7382b47db74a4d79 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:08:02 +0100
Subject: [PATCH 40/53] Refactor Utilities tests with helpers

---
 .../openhft/affinity/impl/UtilitiesTest.java  | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/impl/UtilitiesTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/impl/UtilitiesTest.java b/affinity/src/test/java/net/openhft/affinity/impl/UtilitiesTest.java
new file mode 100644
index 000000000..45d05dbfd
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/impl/UtilitiesTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016-2025 chronicle.software
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.affinity.impl;
+
+import org.junit.Test;
+
+import java.util.BitSet;
+
+import static org.junit.Assert.assertEquals;
+
+public class UtilitiesTest {
+
+    private static String hex(BitSet set, int... bits) {
+        set.clear();
+        for (int b : bits) {
+            set.set(b);
+        }
+        return Utilities.toHexString(set);
+    }
+
+    private static String bin(BitSet set, int... bits) {
+        set.clear();
+        for (int b : bits) {
+            set.set(b);
+        }
+        return Utilities.toBinaryString(set);
+    }
+
+    @Test
+    public void testToHexString() {
+        BitSet set = new BitSet();
+        assertEquals("", hex(set));
+        assertEquals("1", hex(set, 0));
+        assertEquals("10", hex(set, 4));
+        assertEquals(Long.toHexString(1L << 63), hex(set, 63));
+        assertEquals("01", hex(set, 64));
+        assertEquals("101", hex(set, 0, 128));
+    }
+
+    @Test
+    public void testToBinaryString() {
+        BitSet set = new BitSet();
+        assertEquals("", bin(set));
+        assertEquals("1", bin(set, 0));
+        assertEquals("10000", bin(set, 4));
+        assertEquals(Long.toBinaryString(1L << 63), bin(set, 63));
+        assertEquals("01", bin(set, 64));
+        assertEquals("101", bin(set, 0, 128));
+    }
+}

From 4b909869664060a95b396834314aa0d7488db5ea Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:08:14 +0100
Subject: [PATCH 41/53] Add test for negative PID

---
 .../src/test/java/net/openhft/affinity/LockCheckTest.java    | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
index 40f5d18e5..2612886ce 100644
--- a/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/LockCheckTest.java
@@ -55,6 +55,11 @@ public void testPidOnLinux() {
         Assert.assertTrue(LockCheck.isProcessRunning(LockCheck.getPID()));
     }
 
+    @Test
+    public void testNegativePidOnLinux() {
+        Assert.assertFalse(LockCheck.isProcessRunning(-1));
+    }
+
     @Test
     public void testReplace() throws IOException {
         cpu++;

From 67d5ad63340fef52b28a111aef0dbbce4e230db3 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:08:28 +0100
Subject: [PATCH 42/53] Return EMPTY_PID if lock file absent on unsupported OS

---
 .../src/main/java/net/openhft/affinity/LockCheck.java     | 3 +++
 .../java/net/openhft/affinity/FileLockLockCheckTest.java  | 8 ++++++++
 2 files changed, 11 insertions(+)

diff --git a/affinity/src/main/java/net/openhft/affinity/LockCheck.java b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
index 5d3db1535..2953637c3 100644
--- a/affinity/src/main/java/net/openhft/affinity/LockCheck.java
+++ b/affinity/src/main/java/net/openhft/affinity/LockCheck.java
@@ -78,6 +78,9 @@ private synchronized static boolean isLockFree(int id) {
     }
 
     public static int getProcessForCpu(int core) throws IOException {
+        if (!canOSSupportOperation())
+            return EMPTY_PID;
+
         String meta = lockChecker.getMetaInfo(core);
 
         if (meta != null && !meta.isEmpty()) {
diff --git a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
index b155e4999..6be18c5d7 100644
--- a/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/FileLockLockCheckTest.java
@@ -96,4 +96,12 @@ public void lockFileDeletedWhileHeld() throws Exception {
         lockFile = lockChecker.doToFile(cpu);
         Assert.assertTrue("Lock file should be recreated", lockFile.exists());
     }
+
+    @Test
+    public void getProcessForCpuReturnsEmptyPidWhenNoFile() throws IOException {
+        int freeCpu = 99;
+        File lockFile = lockChecker.doToFile(freeCpu);
+        Assert.assertFalse(lockFile.exists());
+        Assert.assertEquals(Integer.MIN_VALUE, LockCheck.getProcessForCpu(freeCpu));
+    }
 }

From 931075da591a10515a38bdeaea809e493f872b9d Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:08:46 +0100
Subject: [PATCH 43/53] test: verify hyper-thread pairs from cpuinfo

---
 .../impl/VanillaCpuLayoutPairTest.java        | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPairTest.java

diff --git a/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPairTest.java b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPairTest.java
new file mode 100644
index 000000000..99986acd3
--- /dev/null
+++ b/affinity/src/test/java/net/openhft/affinity/impl/VanillaCpuLayoutPairTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2016-2025 chronicle.software
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.openhft.affinity.impl;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests for {@link VanillaCpuLayout#pair(int)} using sample cpuinfo files.
+ */
+public class VanillaCpuLayoutPairTest {
+
+    @Test
+    public void testPairForI7() throws IOException {
+        try (InputStream is = getClass().getClassLoader().getResourceAsStream("i7.cpuinfo")) {
+            VanillaCpuLayout layout = VanillaCpuLayout.fromCpuInfo(is);
+            assertEquals(4, layout.pair(0));
+            assertEquals(5, layout.pair(1));
+            assertEquals(6, layout.pair(2));
+            assertEquals(7, layout.pair(3));
+            assertEquals(0, layout.pair(4));
+            assertEquals(1, layout.pair(5));
+            assertEquals(2, layout.pair(6));
+            assertEquals(3, layout.pair(7));
+        }
+    }
+
+    @Test
+    public void testPairForI3() throws IOException {
+        try (InputStream is = getClass().getClassLoader().getResourceAsStream("i3.cpuinfo")) {
+            VanillaCpuLayout layout = VanillaCpuLayout.fromCpuInfo(is);
+            assertEquals(2, layout.pair(0));
+            assertEquals(3, layout.pair(1));
+            assertEquals(0, layout.pair(2));
+            assertEquals(1, layout.pair(3));
+        }
+    }
+}

From 561190e394cc6c6ae8f0c8f4d248b7f68c2ebfb5 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:14:37 +0100
Subject: [PATCH 44/53] Fix typo in Javadoc for ITicker class

---
 affinity/src/main/java/net/openhft/ticker/ITicker.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/affinity/src/main/java/net/openhft/ticker/ITicker.java b/affinity/src/main/java/net/openhft/ticker/ITicker.java
index 407583031..0763f0871 100644
--- a/affinity/src/main/java/net/openhft/ticker/ITicker.java
+++ b/affinity/src/main/java/net/openhft/ticker/ITicker.java
@@ -21,7 +21,7 @@
  * Abstraction of a high resolution time source used throughout the library.
  * <p>
  * Implementations may be based on {@link System#nanoTime()} or platform
- * specific timers such as the processor&apos;s time stamp counter accessed via
+ * specific timers such as the processor's time stamp counter accessed via
  * JNI.  The {@linkplain #ticks() tick values} returned are therefore
  * implementation dependent.  They always increase monotonically but the unit
  * they represent can vary from nanoseconds to CPU cycles.

From 18ae546ead3b6d26659d4d80b01af99707cb04d0 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:20:36 +0100
Subject: [PATCH 45/53] Remove TickerTest.java

---
 .../java/net/openhft/ticker/TickerTest.java   | 30 -------------------
 1 file changed, 30 deletions(-)
 delete mode 100644 affinity/src/test/java/net/openhft/ticker/TickerTest.java

diff --git a/affinity/src/test/java/net/openhft/ticker/TickerTest.java b/affinity/src/test/java/net/openhft/ticker/TickerTest.java
deleted file mode 100644
index 5c803e0ad..000000000
--- a/affinity/src/test/java/net/openhft/ticker/TickerTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package net.openhft.ticker;
-
-import net.openhft.ticker.impl.JNIClock;
-import net.openhft.ticker.impl.SystemClock;
-import org.junit.Test;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-
-import static org.junit.Assert.assertSame;
-
-public class TickerTest {
-    @Test
-    public void whenJniClockUnavailableTickerUsesSystemClock() throws Exception {
-        // Force JNIClock.LOADED to false
-        Field loadedField = JNIClock.class.getDeclaredField("LOADED");
-        loadedField.setAccessible(true);
-        Field modifiersField = Field.class.getDeclaredField("modifiers");
-        modifiersField.setAccessible(true);
-        modifiersField.setInt(loadedField, loadedField.getModifiers() & ~Modifier.FINAL);
-        loadedField.setBoolean(null, false);
-
-        // Load Ticker after modifying JNIClock.LOADED
-        Class<?> tickerClass = Class.forName("net.openhft.ticker.Ticker");
-        Field instanceField = tickerClass.getDeclaredField("INSTANCE");
-        instanceField.setAccessible(true);
-        Object instance = instanceField.get(null);
-        assertSame(SystemClock.INSTANCE, instance);
-    }
-}

From 7993fa83c909c0730ec588d98bf36f2249dbe3c4 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:25:03 +0100
Subject: [PATCH 46/53] Suppress unused warning in AffinityLockDumpLocksTest

---
 .../java/net/openhft/affinity/AffinityLockDumpLocksTest.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
index 00aa020b2..076063441 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
@@ -29,6 +29,7 @@ public void dumpLocksListsThreadsHoldingLocks() throws Exception {
             String name = "worker-" + i;
             Thread t = new Thread(() -> {
                 try (AffinityLock lock = AffinityLock.acquireLock()) {
+                    supressUnusedWarning(lock);
                     acquired.countDown();
                     release.await();
                 } catch (InterruptedException e) {
@@ -51,4 +52,8 @@ public void dumpLocksListsThreadsHoldingLocks() throws Exception {
             t.join();
         }
     }
+
+    static void supressUnusedWarning(AutoCloseable c) {
+        // do nothing
+    }
 }

From d7fd31b225d439377fa4ce8efa0971c734b85c67 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:29:45 +0100
Subject: [PATCH 47/53] Use Long.parseUnsignedLong for parsing reservedAffinity
 in AffinityLock to support bit #63 being set

---
 affinity/src/main/java/net/openhft/affinity/AffinityLock.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
index 3d28c4c86..dfa3f6dc5 100644
--- a/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
+++ b/affinity/src/main/java/net/openhft/affinity/AffinityLock.java
@@ -135,7 +135,7 @@ private static BitSet getReservedAffinity0() {
         int end = reservedAffinity.length();
         for (int i = 0; i < longs.length; i++) {
             int begin = Math.max(0, end - 16);
-            longs[i] = Long.parseLong(reservedAffinity.substring(begin, end), 16);
+            longs[i] = Long.parseUnsignedLong(reservedAffinity.substring(begin, end), 16);
             end = begin;
         }
         return BitSet.valueOf(longs);

From 6ca39326de5f89778c5646f1bd4a84d7cbbb6d78 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:42:29 +0100
Subject: [PATCH 48/53] Simplify thread name assertion in
 AffinityLockDumpLocksTest

---
 .../java/net/openhft/affinity/AffinityLockDumpLocksTest.java   | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
index 076063441..e981e4e12 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockDumpLocksTest.java
@@ -19,7 +19,6 @@ public void dumpLocksListsThreadsHoldingLocks() throws Exception {
         Assume.assumeTrue(new File("/proc/cpuinfo").exists());
 
         AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo());
-
         int nThreads = Math.min(3, Math.max(1, AffinityLock.PROCESSORS - 1));
         CountDownLatch acquired = new CountDownLatch(nThreads);
         CountDownLatch release = new CountDownLatch(1);
@@ -44,7 +43,7 @@ public void dumpLocksListsThreadsHoldingLocks() throws Exception {
 
         String dump = AffinityLock.dumpLocks();
         for (Thread t : threads) {
-            assertTrue("Missing entry for " + t.getName(), dump.contains("Thread[" + t.getName()));
+            assertTrue("Missing entry for " + t.getName(), dump.contains(t.getName()));
         }
 
         release.countDown();

From 93c6d8cc873a5e61d0c7b83c721daeab1a6713b8 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:47:16 +0100
Subject: [PATCH 49/53] Revert move of asString

---
 README.adoc                                        | 14 --------------
 .../net/openhft/affinity/MicroJitterSampler.java   | 14 +++++++-------
 2 files changed, 7 insertions(+), 21 deletions(-)

diff --git a/README.adoc b/README.adoc
index ff1dc7257..91b0eeb06 100644
--- a/README.adoc
+++ b/README.adoc
@@ -370,17 +370,3 @@ try (AffinityLock lock = AffinityLock.acquireLock("0")) { // prints a warning
     assertFalse(lock.bound);
 }
 ----
-
-== Deploying the OSGi Bundle
-
-The ``affinity-test`` module is packaged as an OSGi ``bundle``. Build it with
-
-[source,bash]
-----
-mvn -pl affinity-test clean package
-----
-
-The resulting JAR can be deployed to your OSGi runtime (e.g. Apache Felix or
-Equinox) by copying it into the framework's ``bundle`` directory or by using the
-``install`` and ``start`` commands. For a reference example, see
-``affinity-test/src/test/java/net/openhft/affinity/osgi/OSGiBundleTest.java``.
diff --git a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
index 57851b9e3..21a6e5b3c 100644
--- a/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
+++ b/affinity/src/main/java/net/openhft/affinity/MicroJitterSampler.java
@@ -55,13 +55,6 @@ public static void main(String... ignored) throws InterruptedException {
         t.join();
     }
 
-    private static String asString(long timeNS) {
-        return timeNS < 1000 ? timeNS + "ns" :
-                timeNS < 1000000 ? timeNS / 1000 + "us" :
-                        timeNS < 1000000000 ? timeNS / 1000000 + "ms" :
-                                timeNS / 1000000000 + "sec";
-    }
-
     private void once() throws InterruptedException {
         if (UTIL >= 100) {
             sample(30L * 1000 * 1000 * 1000);
@@ -97,6 +90,13 @@ public void run() {
         }
     }
 
+    private static String asString(long timeNS) {
+        return timeNS < 1000 ? timeNS + "ns" :
+                timeNS < 1000000 ? timeNS / 1000 + "us" :
+                        timeNS < 1000000000 ? timeNS / 1000000 + "ms" :
+                                timeNS / 1000000000 + "sec";
+    }
+
     void reset() {
         for (int i = 0; i < DELAY.length; ++i)
             count[i] = 0;

From ac8173f7c6b80cd380fc1b9224a16a1d6e7d0cd6 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Fri, 23 May 2025 09:48:34 +0100
Subject: [PATCH 50/53] revert comment

---
 .../openhft/affinity/lockchecker/FileLockBasedLockChecker.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
index 4da205991..265d8923f 100644
--- a/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
+++ b/affinity/src/main/java/net/openhft/affinity/lockchecker/FileLockBasedLockChecker.java
@@ -242,7 +242,7 @@ private File tmpDir() {
         final File tempDir = new File(System.getProperty("java.io.tmpdir"));
 
         if (!tempDir.exists())
-            tempDir.mkdirs(); // should warn if it fails
+            tempDir.mkdirs();
 
         return tempDir;
     }

From e6fa8b8b93c8e1b94b7690f52d22aab8d4f91ad1 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Mon, 26 May 2025 11:47:44 +0100
Subject: [PATCH 51/53] Add LICENSE file with Apache License, Version 2.0

---
 LICENSE      | 201 ---------------------------------------------------
 LICENSE.adoc |  14 ++++
 2 files changed, 14 insertions(+), 201 deletions(-)
 delete mode 100644 LICENSE
 create mode 100644 LICENSE.adoc

diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index f7f8b7f7d..000000000
--- a/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2014-2025 chronicle.software
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/LICENSE.adoc b/LICENSE.adoc
new file mode 100644
index 000000000..4c32dfd95
--- /dev/null
+++ b/LICENSE.adoc
@@ -0,0 +1,14 @@
+
+== Copyright 2016-2025 chronicle.software
+
+Licensed under the *Apache License, Version 2.0* (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
\ No newline at end of file

From 8299807d933d5774d019c0b104795f8e2bc73101 Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Mon, 26 May 2025 11:47:49 +0100
Subject: [PATCH 52/53] Remove unnecessary blank line in AffinityLockTest

---
 .../src/test/java/net/openhft/affinity/AffinityLockTest.java     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
index 45243783e..12bc405ab 100644
--- a/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
+++ b/affinity/src/test/java/net/openhft/affinity/AffinityLockTest.java
@@ -44,7 +44,6 @@
 public class AffinityLockTest extends BaseAffinityTest {
     private static final Logger logger = LoggerFactory.getLogger(AffinityLockTest.class);
 
-
     @Test
     public void dumpLocksI7() throws IOException {
         LockInventory lockInventory = new LockInventory(VanillaCpuLayout.fromCpuInfo("i7.cpuinfo"));

From 153651749dd9654c94faf21237901d0d10c357dc Mon Sep 17 00:00:00 2001
From: Peter Lawrey <peter.lawrey@chronicle.software>
Date: Thu, 29 May 2025 10:31:10 +0100
Subject: [PATCH 53/53] Fix formatting issues in documentation files

---
 LICENSE.adoc                             |  2 +-
 README.adoc                              | 57 +++++++++++++-----------
 affinity/src/main/adoc/requirements.adoc | 46 +++++++++----------
 3 files changed, 56 insertions(+), 49 deletions(-)

diff --git a/LICENSE.adoc b/LICENSE.adoc
index 4c32dfd95..eb12fcc48 100644
--- a/LICENSE.adoc
+++ b/LICENSE.adoc
@@ -11,4 +11,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
\ No newline at end of file
+limitations under the License.
diff --git a/README.adoc b/README.adoc
index 91b0eeb06..c51b9f438 100644
--- a/README.adoc
+++ b/README.adoc
@@ -23,13 +23,13 @@ The library detects the running platform in `Affinity.java` and selects an
 implementation for that OS. Features differ between systems:
 
 * *Linux* - full affinity control via JNA. The implementation can get and set
-  thread affinity, query the current CPU, and obtain process and thread IDs.
+thread affinity, query the current CPU, and obtain process and thread IDs.
 * *Windows* - thread affinity is managed through the kernel API. Process and
-  thread IDs are available, while `getCpu()` returns `-1`.
+thread IDs are available, while `getCpu()` returns `-1`.
 * *macOS* - provides process and thread IDs but does not modify affinity and
-  reports the CPU id as `-1`.
+reports the CPU id as `-1`.
 * *Solaris* - mirrors the macOS implementation: only process and thread IDs are
-  returned with no affinity or CPU querying support.
+returned with no affinity or CPU querying support.
 
 === Changes
 
@@ -39,15 +39,16 @@ implementation for that OS. Features differ between systems:
 
 === Dependencies
 
-Java-Thread-Affinity will try to use https://github.com/java-native-access/jna[JNA]
-to provide access to native thread-handling functions. JNA should be installed on
+Java-Thread-Affinity will try to use link:https://github.com/java-native-access/jna[JNA]
+to provide access to native thread-handling functions.
+JNA should be installed on
 your system to get the most from this library.
 
 === JNA version
 
 Java-Thread-Affinity currently depends on JNA version 4.4.0, which in turn
 depends on a version of GLIBC >= 2.14. If your operating system is an old one,
-with a version of GLIBC released before 2011, this library will not be able to 
+with a version of GLIBC released before 2011, this library will not be able to
 invoke native functions.
 
 To work around this problem, fork the repository, and override the `<version>` tag
@@ -55,30 +56,31 @@ for the artifacts `jna` and `jna-platform` in the project's `pom` file.
 
 === Installing JNA on Ubuntu
 
-    sudo apt-get install libjna-java
+sudo apt-get install libjna-java
 
 === Installing JNA on CentOS
 
-    sudo yum install jna
+sudo yum install jna
 
 === Installing JNA on Windows
 
-    choco install jna
+choco install jna
 
 Or download jna.jar and jna-platform.jar from the JNA project and add them to your classpath.
 
 === How does CPU allocation work?
-The library will read your `/proc/cpuinfo` if you have one or provide one and it will determine your CPU layout.  If you don't have one it will assume every CPU is on one CPU socket.
+The library will read your `/proc/cpuinfo` if you have one or provide one and it will determine your CPU layout.
+If you don't have one it will assume every CPU is on one CPU socket.
 
-The library looks for isolated CPUs determined by looking at the CPUs you are not running on by default. 
+The library looks for isolated CPUs determined by looking at the CPUs you are not running on by default.
 i.e. if you have 16 CPUs but 8 of them are not available for general use (as determined by the affinity of the process on startup) it will start assigning to those CPUs.
 
 Note: if you have more than one process using this library you need to specify which CPUs the process can use otherwise it will assign the same CPUs to both processes.
 
-To control which CPUs a process can use, add `-Daffinity.reserved={cpu-mask-in-hex}`
-to the command line of the process. The mask is a hexadecimal bit mask without
-the `0x` prefix where bit `0` represents CPU `0`, bit `1` represents CPU `1` and
-so on. Multiple CPUs can be specified by setting more than one bit.
+To control which CPUs a process can use, add `-Daffinity.reserved={cpu-mask-in-hex}` to the command line of the process.
+The mask is a hexadecimal bit mask without
+the `0x` prefix where bit `0` represents CPU `0`, bit `1` represents CPU `1` and so on.
+Multiple CPUs can be specified by setting more than one bit.
 
 For example:
 
@@ -103,7 +105,8 @@ http://vanillajava.blogspot.co.uk/2013/07/micro-jitter-busy-waiting-and-binding.
 
 Java-Thread-Affinity requires that you first isolate some CPU's.
 
-Once a CPU core is isolated, the Linux scheduler will not use the CPU core to run any user-space processes. The isolated CPUs will not participate in load balancing, and will not have tasks running on them unless explicitly assigned.
+Once a CPU core is isolated, the Linux scheduler will not use the CPU core to run any user-space processes.
+The isolated CPUs will not participate in load balancing, and will not have tasks running on them unless explicitly assigned.
 
 To isolate the 1st and 3rd CPU cores (CPU numbers start from 0) on your system, add the following to the kernel command line during boot:
 
@@ -150,7 +153,8 @@ try (AffinityLock al = AffinityLock.acquireLock()) {
 You have further options such as
 
 === Acquiring a CORE lock for a thread
-You can reserve a whole core.  If you have hyper-threading enabled, this will use one CPU and leave it's twin CPU unused.
+You can reserve a whole core.
+If you have hyper-threading enabled, this will use one CPU and leave it's twin CPU unused.
 [source, java]
 ----
 try (AffinityLock al = AffinityLock.acquireCore()) {
@@ -174,7 +178,7 @@ try (final AffinityLock al = AffinityLock.acquireLock()) {
     });
     t.start();
 }
-----    
+----
 In this example, the library will prefer a free CPU on the same Socket as the first thread, otherwise it will pick any free CPU.
 
 === Affinity strategies
@@ -211,12 +215,12 @@ The affinity of the process on start up is
 ----
 
 long baseAffinity = AffinityLock.BASE_AFFINITY;
-----   
+----
 The available CPU for reservation is
 [source, java]
 ----
 long reservedAffinity = AffinityLock.RESERVED_AFFINITY;
-----    
+----
 If you want to get/set the affinity directly you can do
 [source, java]
 ----
@@ -240,7 +244,8 @@ of that CPU. Example output might look like:
 
 The number on each line is the logical CPU index as recognised by the library.
 The text after the colon describes whether that CPU is free, reserved or already
-bound to a thread. Use these indices when calling `AffinityLock.acquireLock(n)`
+bound to a thread.
+Use these indices when calling `AffinityLock.acquireLock(n)`
 or when constructing explicit affinity masks.
 
 === Lock file directory
@@ -289,8 +294,8 @@ $ for i in "$(ls cpu-*)";
 
 == Using AffinityThreadFactory
 
-`AffinityThreadFactory` binds each thread it creates according to a set of
-`AffinityStrategy` rules.  This allows executors to automatically run tasks on
+`AffinityThreadFactory` binds each thread it creates according to a set of `AffinityStrategy` rules.
+This allows executors to automatically run tasks on
 cores selected by the library.
 
 [source, java]
@@ -315,7 +320,9 @@ For an article on how much difference affinity can make and how to use it http:/
 == Questions and Answers
 
 === Question: How to lock a specific cpuId
-I am currently working on a project related to deadlock detection in multithreaded programs in java. We are trying to run threads on different processors and thus came across your github posts regarding the same. https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/Getting-started
+I am currently working on a project related to deadlock detection in multithreaded programs in java.
+We are trying to run threads on different processors and thus came across your github posts regarding the same.
+https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/Getting-started
 Being a beginner, I have little knowledge and thus need your assistance. We need to know how to run threads on specified cpu number and then switch threads when one is waiting. 
 
 === Answer
diff --git a/affinity/src/main/adoc/requirements.adoc b/affinity/src/main/adoc/requirements.adoc
index f15cf0ed4..7cfacee5e 100644
--- a/affinity/src/main/adoc/requirements.adoc
+++ b/affinity/src/main/adoc/requirements.adoc
@@ -1,14 +1,11 @@
 = Requirements Document: Java Thread Affinity
-Author: Gemini AI
-Date: 23 May 2025
-Version: 1.0
-:toc: left
-:toclevels: 3
-:sectnums:
+:toc:
 
 == 1. Introduction
 
-This document outlines the requirements for the *Java Thread Affinity* library. The primary purpose of this library is to provide Java applications with the capability to control Central Processing Unit (CPU) affinity for their threads. This allows developers to bind specific threads to designated CPU cores, which can lead to performance improvements, especially in latency-sensitive applications, by reducing context switching and improving cache utilisation.
+This document outlines the requirements for the *Java Thread Affinity* library.
+The primary purpose of this library is to provide Java applications with the capability to control Central Processing Unit (CPU) affinity for their threads.
+This allows developers to bind specific threads to designated CPU cores, which can lead to performance improvements, especially in latency-sensitive applications, by reducing context switching and improving cache utilisation.
 
 The library aims to offer a cross-platform API, with the most comprehensive support for Linux systems, leveraging Java Native Access (JNA) and, where applicable, Java Native Interface (JNI) for low-level system interactions.
 
@@ -26,23 +23,25 @@ The scope of the Java Thread Affinity project includes:
 
 == 3. Definitions, Acronyms, and Abbreviations
 
-* *CPU*: Central Processing Unit
-* *JNA*: Java Native Access
-* *JNI*: Java Native Interface
-* *OS*: Operating System
-* *PID*: Process Identifier
-* *OSGi*: Open Service Gateway initiative
-* *POM*: Project Object Model (Maven)
-* *API*: Application Programming Interface
+CPU :: Central Processing Unit
+JNA :: Java Native Access
+JNI :: Java Native Interface
+OS :: Operating System
+PID :: Process Identifier
+OSGi :: Open Service Gateway initiative
+POM :: Project Object Model (Maven)
+API :: Application Programming Interface
 
 == 4. References
 
-* Project Repository: https://github.com/OpenHFT/Java-Thread-Affinity
-* JNA: https://github.com/java-native-access/jna
+* Project Repository: link:https://github.com/OpenHFT/Java-Thread-Affinity[]
+* JNA: link:https://github.com/java-native-access/jna[]
 
 == 5. Project Overview
 
-The *Java Thread Affinity* library enables fine-grained control over which CPU cores Java threads execute on. This is particularly beneficial for high-performance computing and low-latency applications where minimising jitter and maximising cache efficiency is critical. The library abstracts OS-specific details, providing a unified Java API.
+The *Java Thread Affinity* library enables fine-grained control over which CPU cores Java threads execute on.
+This is particularly beneficial for high-performance computing and low-latency applications where minimising jitter and maximising cache efficiency is critical.
+The library abstracts OS-specific details, providing a unified Java API.
 
 === 5.1. Purpose
 
@@ -152,12 +151,12 @@ The *Java Thread Affinity* library enables fine-grained control over which CPU c
 === 6.8. Native Code Compilation (C/C++)
 
 * *FR12.1*: The system _shall_ include C/C++ source code for native functions required for affinity and timer operations on Linux and macOS.
-    ** `software_chronicle_enterprise_internals_impl_NativeAffinity.cpp` (Linux)
-    ** `software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c` (macOS)
-    ** `net_openhft_ticker_impl_JNIClock.cpp` (for `rdtsc`)
+** `software_chronicle_enterprise_internals_impl_NativeAffinity.cpp` (Linux)
+** `software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c` (macOS)
+** `net_openhft_ticker_impl_JNIClock.cpp` (for `rdtsc`)
 * *FR12.2*: A Makefile _shall_ be provided to compile the native C/C++ code into a shared library (`libCEInternals.so`).
 * *FR12.3*: The Java code _shall_ load this native library if available.
-** `software.chronicle.enterprise.internals.impl.NativeAffinity.loadAffinityNativeLibrary()`
+*** `software.chronicle.enterprise.internals.impl.NativeAffinity.loadAffinityNativeLibrary()`
 
 == 7. Non-Functional Requirements
 
@@ -192,7 +191,8 @@ The *Java Thread Affinity* library enables fine-grained control over which CPU c
 
 === 8.1. High-Level Architecture
 
-The Java Thread Affinity library is a Java-based system that interfaces with the underlying operating system through JNA (primarily) and JNI (for specific `libCEInternals.so` functionalities). It abstracts OS-specific system calls related to thread affinity, CPU information, and timing.
+The Java Thread Affinity library is a Java-based system that interfaces with the underlying operating system through JNA (primarily) and JNI (for specific `libCEInternals.so` functionalities).
+It abstracts OS-specific system calls related to thread affinity, CPU information, and timing.
 
 === 8.2. Key Components