pax_global_header00006660000000000000000000000064143575013100014511gustar00rootroot0000000000000052 comment=7556981394266858e3ac55b4dffbe00258652b9a Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/000077500000000000000000000000001435750131000212715ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/.gitignore000066400000000000000000000012401435750131000232560ustar00rootroot00000000000000### How to update # This is copied from OpenHFT/.gitignore # update the original and run OpenHFT/update_gitignore.sh ### Compiled class file *.class ### Package Files *.jar *.war *.ear ### Log file *.log ### IntelliJ *.iml *.ipr *.iws .idea compat_reports .attach_pid* ### Virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* ### Maven template target/ pom.xml.tag pom.xml.releaseBackup pom.xml.versionsBackup pom.xml.next release.properties ### Eclipse template *.pydevproject .metadata .gradle bin/ tmp/ *.tmp *.bak *.swp *~.nib local.properties .classpath .project .settings/ .loadpath ### Queue files *.cq4t *.cq4 Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/LICENSE000066400000000000000000000261351435750131000223050ustar00rootroot00000000000000 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-2018 Chronicle Software Ltd 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. Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/README.adoc000066400000000000000000000177361435750131000230740ustar00rootroot00000000000000= Thread Affinity image::docs/images/Thread-Affinity_line.png[width=20%] == Version [#image-maven] [caption="", link=https://maven-badges.herokuapp.com/maven-central/net.openhft/affinity] image::https://maven-badges.herokuapp.com/maven-central/net.openhft/affinity/badge.svg[] image:https://javadoc.io/badge2/net.openhft/affinity/javadoc.svg[link="https://www.javadoc.io/doc/net.openhft/affinity/latest/index.html"] == Overview Lets you bind a thread to a given core, this can improve performance (this library works best on linux). 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. === Changes * V3.2.0 - Add support for text configuration * V3.1.1 - Upgraded JNA dependency to 4.4.0 * V2.0.1 - Added getThreadId for the process if of the thread. === 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 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 invoke native functions. To work around this problem, fork the repository, and override the `` tag for the artifacts `jna` and `jna-platform` in the project's `pom` file. === Installing JNA on Ubuntu sudo apt-get install libjna-java === Installing JNA on CentOS sudo yum install jna === 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 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. Note: the CPU 0 is reserved for the Operating System, it has to run somewhere. === References https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/Getting-started https://github.com/peter-lawrey/Java-Thread-Affinity/wiki/How-it-works http://vanillajava.blogspot.co.uk/2013/07/micro-jitter-busy-waiting-and-binding.html === isolcpus 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. 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: isolcpus=1,3 == Using AffinityLock === Acquiring a CPU lock for a thread You can acquire a lock for a CPU in the following way: In Java 6 [source, java] ---- AffinityLock al = AffinityLock.acquireLock(); try { // do some work locked to a CPU. } finally { al.release(); } ---- In Java 7 or 8 [source, java] ---- try (AffinityLock al = AffinityLock.acquireLock()) { // do some work while locked to a CPU. } ---- 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. [source, java] ---- try (AffinityLock al = AffinityLock.acquireCore()) { // do some work while locked to a CPU. } ---- === Controlling layout You can chose a layout relative to an existing lock. [source, java] ---- try (final AffinityLock al = AffinityLock.acquireLock()) { System.out.println("Main locked"); Thread t = new Thread(new Runnable() { @Override public void run() { try (AffinityLock al2 = al.acquireLock(AffinityStrategies.SAME_SOCKET, AffinityStrategies.ANY)) { System.out.println("Thread-0 locked"); } } }); 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. === Getting the thread id You can get the current thread id using [source, java] ---- int threadId = AffinitySupport.getThreadId(); ---- === Determining which CPU you are running on You can get the current CPU being used by [source, java] ---- int cpuId = AffinitySupport.getCpu(); ---- === Controlling the affinity more directly The affinity of the process on start up is [source, java] ---- 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] ---- long currentAffinity = AffinitySupport.getAffinity(); AffinitySupport.setAffinity(1L << 5); // lock to CPU 5. ---- === Debugging affinity state For a detailed of view of the current affinity state (as seen by the library), execute the following script on Linux systems: [source] ---- # change to the affinity lock-file directory (defaults to system property java.io.tmpdir) $ cd /tmp # dump affinity state $ for i in "$(ls cpu-*)"; do PID="$(cat $i | head -n1)"; TIMESTAMP="$(cat $i | tail -n1)"; echo "pid $PID locked at $TIMESTAMP in $i"; taskset -cp $PID; cat "/proc/$PID/cmdline"; echo; echo done pid 14584 locked at 2017.10.30 at 10:33:24 GMT in cpu-3.lock pid 14584's current affinity list: 3 /opt/jdk1.8.0_141/bin/java ... ---- == Support Material https://groups.google.com/forum/?hl=en-GB#!forum/java-thread-affinity[Java Thread Affinity support group] For an article on how much difference affinity can make and how to use it http://vanillajava.blogspot.com/2013/07/micro-jitter-busy-waiting-and-binding.html == 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 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 [source, java] ---- // lock a cpuId try (AffinityLock lock = AffinityLock.acquireLock(n)) { } ---- where n is the cpu you want to run the thread on. OR [source,java] ---- // lock one of the last CPUs try (AffinityLock lock = AffinityLock.acquireLockLastMinus(n)) { } ---- === Question: how to use a configuration file to set the cpuId I have the cpuId in a configuration file, how can I set it using a string? === Answer: use one of the following [source,java] ---- try (AffinityLock lock = AffinityLock.acquireLock("last")) { assertEquals(PROCESSORS - 1, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("last-1")) { assertEquals(PROCESSORS - 2, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("1")) { assertEquals(1, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("any")) { assertTrue(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock("none")) { assertFalse(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock((String) null)) { assertFalse(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock("0")) { // prints a warning assertFalse(lock.bound); } ---- Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/000077500000000000000000000000001435750131000240575ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/pom.xml000066400000000000000000000165601435750131000254040ustar00rootroot00000000000000 4.0.0 net.openhft java-parent-pom 1.1.33 affinity-test 3.23.3 bundle OpenHFT/Java-Thread-Affinity/affinity-test Java Thread Affinity library UTF-8 net.openhft third-party-bom pom 3.22.4 import net.openhft affinity ${project.version} net.openhft affinity javax.inject javax.inject test org.osgi org.osgi.core test org.osgi org.osgi.compendium test org.ops4j.pax.exam pax-exam-container-native test org.ops4j.pax.exam pax-exam-junit4 test org.ops4j.pax.exam pax-exam-link-mvn test org.ops4j.pax.url pax-url-aether test org.ops4j.pax.url pax-url-reference test org.apache.felix org.apache.felix.framework test org.slf4j slf4j-api test org.slf4j slf4j-simple test org.apache.maven.plugins maven-compiler-plugin -Xlint:deprecation 1.8 1.8 UTF-8 org.apache.servicemix.tooling depends-maven-plugin generate-depends-file generate-depends-file org.apache.felix maven-bundle-plugin true ${project.groupId}.${project.artifactId} ${project.artifactId} net.openhft.affinity.osgi * manifest pre-java9 com.sun tools 1.8.0 system ${java.home}/../lib/tools.jar ${java.home}/../lib/tools.jar scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git Java-Thread-Affinity-3.23.3 scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/000077500000000000000000000000001435750131000246465ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/000077500000000000000000000000001435750131000255725ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/000077500000000000000000000000001435750131000265135ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/net/000077500000000000000000000000001435750131000273015ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/net/openhft/000077500000000000000000000000001435750131000307445ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/net/openhft/affinity/000077500000000000000000000000001435750131000325555ustar00rootroot00000000000000osgi/000077500000000000000000000000001435750131000334375ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/net/openhft/affinityOSGiPlaceholder.java000066400000000000000000000013371435750131000372520ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/main/java/net/openhft/affinity/osgi/* * Copyright 2016-2020 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.osgi; /** * A placeholder to have some plugin works */ public class OSGiPlaceholder { } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/000077500000000000000000000000001435750131000256255ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/000077500000000000000000000000001435750131000265465ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/000077500000000000000000000000001435750131000273345ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/openhft/000077500000000000000000000000001435750131000307775ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/openhft/affinity/000077500000000000000000000000001435750131000326105ustar00rootroot00000000000000osgi/000077500000000000000000000000001435750131000334725ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/openhft/affinityOSGiBundleTest.java000066400000000000000000000055101435750131000371310ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/openhft/affinity/osgi/* * Copyright 2016-2020 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.osgi; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.ops4j.pax.exam.Configuration; import org.ops4j.pax.exam.Option; import org.ops4j.pax.exam.junit.PaxExam; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; import javax.inject.Inject; import static org.junit.Assert.*; import static org.ops4j.pax.exam.CoreOptions.*; @Ignore("TODO FIX") @RunWith(PaxExam.class) public class OSGiBundleTest extends net.openhft.affinity.osgi.OSGiTestBase { @Inject BundleContext context; @Configuration public Option[] config() { return options( systemProperty("org.osgi.framework.storage.clean").value("true"), systemProperty("org.ops4j.pax.logging.DefaultServiceLog.level").value("WARN"), mavenBundleAsInProject("org.slf4j", "slf4j-api"), mavenBundleAsInProject("org.slf4j", "slf4j-simple").noStart(), mavenBundleAsInProject("net.openhft", "affinity"), workspaceBundle("affinity-test"), junitBundles(), systemPackage("sun.misc"), systemPackage("sun.nio.ch"), systemPackage("com.sun.jna"), systemPackage("com.sun.jna.ptr"), cleanCaches() ); } @Test public void checkInject() { assertNotNull(context); } @Test public void checkBundleState() { final Bundle bundle = findBundle(context, "net.openhft.affinity"); assertNotNull(bundle); assertEquals(bundle.getState(), Bundle.ACTIVE); } @Test public void checkBundleExports() { final Bundle bundle = findBundle(context, "net.openhft.affinity"); assertNotNull(bundle); final String exports = bundle.getHeaders().get("Export-Package"); final String[] packages = exports.split(","); assertTrue(packages.length >= 2); assertTrue(packages[0].startsWith("net.openhft.affinity;") || packages[0].startsWith("net.openhft.affinity.impl;")); assertTrue(packages[1].startsWith("net.openhft.affinity;") || packages[1].startsWith("net.openhft.affinity.impl;")); } } OSGiTestBase.java000066400000000000000000000041571435750131000366000ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity-test/src/test/java/net/openhft/affinity/osgi/* * Copyright 2016-2020 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.osgi; import org.ops4j.pax.exam.CoreOptions; import org.ops4j.pax.exam.Option; import org.ops4j.pax.exam.options.MavenArtifactProvisionOption; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; import java.io.File; public class OSGiTestBase { public static Option workspaceBundle(String projectName) { String baseDir = System.getProperty("main.basedir"); String bundleDir = null; bundleDir = String.format("%s/%s/target/classes", baseDir, projectName); if (new File(bundleDir).exists()) { return CoreOptions.bundle(String.format("reference:file:%s", bundleDir)); } bundleDir = String.format("%s/../%s/target/classes", baseDir, projectName); if (new File(bundleDir).exists()) { return CoreOptions.bundle(String.format("reference:file:%s", bundleDir)); } return null; } public static MavenArtifactProvisionOption mavenBundleAsInProject(final String groupId, final String artifactId) { return CoreOptions.mavenBundle().groupId(groupId).artifactId(artifactId).versionAsInProject(); } public static Bundle findBundle(BundleContext context, String symbolicName) { Bundle[] bundles = context.getBundles(); for (Bundle bundle : bundles) { if (bundle != null) { if (bundle.getSymbolicName().equals(symbolicName)) { return bundle; } } } return null; } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/000077500000000000000000000000001435750131000231025ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/pom.xml000066400000000000000000000253741435750131000244320ustar00rootroot00000000000000 4.0.0 net.openhft java-parent-pom 1.1.33 affinity 3.23.3 bundle OpenHFT/Java-Thread-Affinity/affinity Java Thread Affinity library src/main/c UTF-8 net.openhft third-party-bom pom 3.22.4 import net.openhft chronicle-bom 2.23.143 pom import org.slf4j slf4j-api net.java.dev.jna jna net.java.dev.jna jna-platform org.jetbrains annotations org.easymock easymock test junit junit test org.slf4j slf4j-simple test net.openhft chronicle-test-framework test slf4j-simple org.slf4j slf4j-simple make-c !dontMake org.codehaus.mojo exec-maven-plugin 3.1.0 build-native process-classes exec ${project.basedir}/${native.source.dir}/Makefile ${project.basedir}/${native.source.dir} sonar org.sonarsource.scanner.maven sonar-maven-plugin org.jacoco jacoco-maven-plugin prepare-agent report prepare-package report org.apache.maven.plugins maven-compiler-plugin -h ${project.build.directory}/jni -Xlint:deprecation 1.8 1.8 UTF-8 org.apache.maven.plugins maven-scm-publish-plugin ${project.build.directory}/scmpublish/javadoc Publishing javadoc for ${project.artifactId}:${project.version} ${project.reporting.outputDirectory} true scm:git:git@github.com:OpenHFT/Java-Thread-Affinity gh-pages org.apache.servicemix.tooling depends-maven-plugin generate-depends-file generate-depends-file org.apache.felix maven-bundle-plugin true ${project.groupId}.${project.artifactId} OpenHFT :: ${project.artifactId} ${project.version} com.sun.jna.platform.*;resolution:=optional, * net.openhft.affinity.*;-noimport:=true, net.openhft.ticker.*;-noimport:=true manifest chronicle-enterprise-snapshots Snapshot Repository https://nexus.chronicle.software/content/repositories/snapshots true chronicle-enterprise-release https://nexus.chronicle.software/content/repositories/releases true scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git Java-Thread-Affinity-3.23.3 Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/000077500000000000000000000000001435750131000236715ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/000077500000000000000000000000001435750131000246155ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/c/000077500000000000000000000000001435750131000250375ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/c/Makefile000077500000000000000000000021301435750131000264760ustar00rootroot00000000000000#!/usr/bin/make -f # # Makefile for C code # # C sources to compile TARGET_DIR := ../../../target/classes TARGET := $(TARGET_DIR)/libCEInternals.so WORKING_DIR := $(TARGET_DIR)/../jni JAVA_CLASSES = software.chronicle.enterprise.internals.impl.NativeAffinity net.openhft.ticker.impl.JNIClock JNI_STUBS := $(subst .,_,$(JAVA_CLASSES)) JNI_SOURCES := $(patsubst %,%.cpp,$(JNI_STUBS)) JAVA_BUILD_DIR := $(TARGET_DIR) JAVA_HOME ?= /usr/java/default JAVA_LIB := $(JAVA_HOME)/jre/lib JVM_SHARED_LIBS := -L$(JAVA_LIB)/amd64/server -L$(JAVA_LIB)/i386/server -L$(JAVA_LIB)/amd64/jrockit/ -L$(JAVA_LIB)/i386/jrockit/ -L$(JAVA_LIB)/ppc64le/server -L$(JAVA_LIB)/ppc64le/jrockit/ -L$(JAVA_HOME)/lib/server CXX=g++ INCLUDES := -I $(JAVA_HOME)/include -I $(JAVA_HOME)/include/linux -I $(WORKING_DIR) # classpath for javah ifdef CLASSPATH JAVAH_CLASSPATH = $(JAVA_BUILD_DIR):$(CLASSPATH) else JAVAH_CLASSPATH = $(JAVA_BUILD_DIR) endif .PHONY : clean all: $(TARGET) $(TARGET): $(JNI_SOURCES) $(CXX) -O3 -Wall -shared -fPIC $(JVM_SHARED_LIBS) -ljvm -lrt $(INCLUDES) $(JNI_SOURCES) -o $(TARGET) clean: rm $(TARGET) net_openhft_ticker_impl_JNIClock.cpp000066400000000000000000000035531435750131000340410ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/c/* vim: syntax=cpp * Copyright 2015 Higher Frequency Trading * * 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. */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include #include "net_openhft_ticker_impl_JNIClock.h" #if defined(__i386__) static __inline__ unsigned long long rdtsc(void) { unsigned long long int x; __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)); return x; } #elif defined(__x86_64__) static __inline__ unsigned long long rdtsc(void) { unsigned hi, lo; __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 ); } #elif defined(__MIPS_32__) #define rdtsc(dest) \ _ _asm_ _ _ _volatile_ _("mfc0 %0,$9; nop" : "=r" (dest)) #elif defined(__MIPS_SGI__) #include static __inline__ unsigned long long rdtsc (void) { struct timespec tp; clock_gettime (CLOCK_SGI_CYCLE, &tp); return (unsigned long long)(tp.tv_sec * (unsigned long long)1000000000) + (unsigned long long)tp.tv_nsec; } #elif defined(__PPC64__) unsigned long long rdtsc(){ unsigned long long rval; __asm__ __volatile__("mfspr %%r3, 268": "=r" (rval)); return rval; } #endif /* * Class: net_openhft_clock_impl_JNIClock * Method: rdtsc0 * Signature: ()J */ JNIEXPORT jlong JNICALL Java_net_openhft_ticker_impl_JNIClock_rdtsc0 (JNIEnv *env, jclass c) { return (jlong) rdtsc(); } software_chronicle_enterprise_internals_impl_NativeAffinity.cpp000066400000000000000000000057611435750131000417150ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/c/* vim: syntax=cpp * Copyright 2011 Higher Frequency Trading * * 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. */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include #include #include #include #include #include #include "software_chronicle_enterprise_internals_impl_NativeAffinity.h" /* * Class: software_chronicle_enterprise_internals_impl_NativeAffinity * Method: getAffinity0 * Signature: ()J */ JNIEXPORT jbyteArray JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getAffinity0 (JNIEnv *env, jclass c) { // The default size of the structure supports 1024 CPUs, should be enough // for now In the future we can use dynamic sets, which can support more // CPUs, given OS can handle them as well cpu_set_t mask; const size_t size = sizeof(mask); int res = sched_getaffinity(0, size, &mask); if (res < 0) { return NULL; } jbyteArray ret = env->NewByteArray(size); jbyte* bytes = env->GetByteArrayElements(ret, 0); memcpy(bytes, &mask, size); env->SetByteArrayRegion(ret, 0, size, bytes); return ret; } /* * Class: software_chronicle_enterprise_internals_NativeAffinity * Method: setAffinity0 * Signature: (J)V */ JNIEXPORT void JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_setAffinity0 (JNIEnv *env, jclass c, jbyteArray affinity) { cpu_set_t mask; const size_t size = sizeof(mask); CPU_ZERO(&mask); jbyte* bytes = env->GetByteArrayElements(affinity, 0); memcpy(&mask, bytes, size); sched_setaffinity(0, size, &mask); } /* * Class: software_chronicle_enterprise_internals_impl_NativeAffinity * Method: getProcessId0 * Signature: ()I */ JNIEXPORT jint JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getProcessId0 (JNIEnv *env, jclass c) { return (jint) getpid(); } /* * Class: software_chronicle_enterprise_internals_impl_NativeAffinity * Method: getThreadId0 * Signature: ()I */ JNIEXPORT jint JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getThreadId0 (JNIEnv *env, jclass c) { return (jint) (pid_t) syscall (SYS_gettid); } /* * Class: software_chronicle_enterprise_internals_impl_NativeAffinity * Method: getCpu0 * Signature: ()I */ JNIEXPORT jint JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getCpu0 (JNIEnv *env, jclass c) { return (jint) sched_getcpu(); } software_chronicle_enterprise_internals_impl_NativeAffinity_MacOSX.c000066400000000000000000000044461435750131000425260ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/c/* * Copyright 2011-2012 Peter Lawrey & Jerry Shea * * 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. */ #include #include #include #include "software_chronicle_enterprise_internals_impl_NativeAffinity.h" /* * Class: software_chronicle_enterprise_internals_impl_NativeAffinity * Method: getAffinity0 * Signature: ()J */ JNIEXPORT jlong JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_getAffinity0 (JNIEnv *env, jclass c) { thread_port_t threadport = pthread_mach_thread_np(pthread_self()); struct thread_enterprise_internals_policy policy; policy.affinity_tag = 0; mach_msg_type_number_t count = THREAD_AFFINITY_POLICY_COUNT; boolean_t get_default = FALSE; if ((thread_policy_get(threadport, THREAD_AFFINITY_POLICY, (thread_policy_t)&policy, &count, &get_default)) != KERN_SUCCESS) { return ~0LL; } return (jlong) policy.affinity_tag; } /* * Class: software_chronicle_enterprise_internals_NativeAffinity * Method: setAffinity0 * Signature: (J)V */ JNIEXPORT void JNICALL Java_software_chronicle_enterprise_internals_impl_NativeAffinity_setAffinity0 (JNIEnv *env, jclass c, jlong affinity) { thread_port_t threadport = pthread_mach_thread_np(pthread_self()); struct thread_enterprise_internals_policy policy; policy.affinity_tag = affinity; int rc = thread_policy_set(threadport, THREAD_AFFINITY_POLICY, (thread_policy_t)&policy, THREAD_AFFINITY_POLICY_COUNT); if (rc != KERN_SUCCESS) { jclass ex = (*env)->FindClass(env, "java/lang/RuntimeException"); char msg[100]; sprintf(msg, "Bad return value from thread_policy_set: %d", rc); (*env)->ThrowNew(env, ex, msg); } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/000077500000000000000000000000001435750131000255365ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/000077500000000000000000000000001435750131000263245ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/000077500000000000000000000000001435750131000277675ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/000077500000000000000000000000001435750131000316005ustar00rootroot00000000000000Affinity.java000066400000000000000000000162031435750131000341370ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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.*; import org.jetbrains.annotations.NotNull; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.PrintWriter; import java.io.StringWriter; import java.lang.reflect.Field; import java.util.BitSet; /** * Library to wrap low level JNI or JNA calls. Can be called without needing to know the actual * implementation used. * * @author peter.lawrey */ public enum Affinity { ; // none static final Logger LOGGER = LoggerFactory.getLogger(Affinity.class); @NotNull private static final IAffinity AFFINITY_IMPL; private static Boolean JNAAvailable; static { String osName = System.getProperty("os.name"); if (osName.contains("Win") && isWindowsJNAAffinityUsable()) { LOGGER.trace("Using Windows JNA-based affinity control implementation"); AFFINITY_IMPL = WindowsJNAAffinity.INSTANCE; } else if (osName.contains("x")) { /*if (osName.startsWith("Linux") && NativeAffinity.LOADED) { LOGGER.trace("Using Linux JNI-based affinity control implementation"); AFFINITY_IMPL = NativeAffinity.INSTANCE; } else*/ if (osName.startsWith("Linux") && isLinuxJNAAffinityUsable()) { LOGGER.trace("Using Linux JNA-based affinity control implementation"); AFFINITY_IMPL = LinuxJNAAffinity.INSTANCE; } else if (isPosixJNAAffinityUsable()) { LOGGER.trace("Using Posix JNA-based affinity control implementation"); AFFINITY_IMPL = PosixJNAAffinity.INSTANCE; } else { LOGGER.info("Using dummy affinity control implementation"); AFFINITY_IMPL = NullAffinity.INSTANCE; } } else if (osName.contains("Mac") && isMacJNAAffinityUsable()) { LOGGER.trace("Using MAC OSX JNA-based thread id implementation"); AFFINITY_IMPL = OSXJNAAffinity.INSTANCE; } else if (osName.contains("SunOS") && isSolarisJNAAffinityUsable()) { LOGGER.trace("Using Solaris JNA-based thread id implementation"); AFFINITY_IMPL = SolarisJNAAffinity.INSTANCE; } else { LOGGER.info("Using dummy affinity control implementation"); AFFINITY_IMPL = NullAffinity.INSTANCE; } } public static IAffinity getAffinityImpl() { return AFFINITY_IMPL; } private static boolean isWindowsJNAAffinityUsable() { if (isJNAAvailable()) { try { return WindowsJNAAffinity.LOADED; } catch (Throwable t) { logThrowable(t, "Windows JNA-based affinity not usable because it failed to load!"); return false; } } else { LOGGER.warn("Windows JNA-based affinity not usable due to JNA not being available!"); return false; } } private static boolean isPosixJNAAffinityUsable() { if (isJNAAvailable()) { try { return PosixJNAAffinity.LOADED; } catch (Throwable t) { logThrowable(t, "Posix JNA-based affinity not usable because it failed to load!"); return false; } } else { LOGGER.warn("Posix JNA-based affinity not usable due to JNA not being available!"); return false; } } private static boolean isLinuxJNAAffinityUsable() { if (isJNAAvailable()) { try { return LinuxJNAAffinity.LOADED; } catch (Throwable t) { logThrowable(t, "Linux JNA-based affinity not usable because it failed to load!"); return false; } } else { LOGGER.warn("Linux JNA-based affinity not usable due to JNA not being available!"); return false; } } private static boolean isMacJNAAffinityUsable() { if (isJNAAvailable()) { return true; } else { LOGGER.warn("MAX OSX JNA-based affinity not usable due to JNA not being available!"); return false; } } private static boolean isSolarisJNAAffinityUsable() { if (isJNAAvailable()) { return true; } else { LOGGER.warn("Solaris JNA-based affinity not usable due to JNA not being available!"); return false; } } private static void logThrowable(Throwable t, String description) { StringWriter sw = new StringWriter(); sw.append(description); sw.append(" Reason: "); t.printStackTrace(new PrintWriter(sw)); LOGGER.warn(sw.toString()); } public static BitSet getAffinity() { return AFFINITY_IMPL.getAffinity(); } public static void setAffinity(final BitSet affinity) { AFFINITY_IMPL.setAffinity(affinity); } public static void setAffinity(int cpu) { BitSet affinity = new BitSet(Runtime.getRuntime().availableProcessors()); affinity.set(cpu); setAffinity(affinity); } public static int getCpu() { return AFFINITY_IMPL.getCpu(); } public static int getThreadId() { return AFFINITY_IMPL.getThreadId(); } public static void setThreadId() { try { int threadId = Affinity.getThreadId(); final Field tid = Thread.class.getDeclaredField("tid"); tid.setAccessible(true); final Thread thread = Thread.currentThread(); tid.setLong(thread, threadId); Affinity.LOGGER.info("Set {} to thread id {}", thread.getName(), threadId); } catch (Exception e) { throw new IllegalStateException(e); } } public static boolean isJNAAvailable() { if (JNAAvailable == null) try { Class.forName("com.sun.jna.Platform"); JNAAvailable = true; } catch (ClassNotFoundException ignored) { JNAAvailable = false; } return JNAAvailable; } public static AffinityLock acquireLock() { return AffinityLock.acquireLock(); } public static AffinityLock acquireCore() { return AffinityLock.acquireCore(); } public static AffinityLock acquireLock(boolean bind) { return AffinityLock.acquireLock(bind); } public static AffinityLock acquireCore(boolean bind) { return AffinityLock.acquireCore(bind); } public static void resetToBaseAffinity() { Affinity.setAffinity(AffinityLock.BASE_AFFINITY); } } AffinityLock.java000066400000000000000000000402321435750131000347470ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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.NoCpuLayout; import net.openhft.affinity.impl.VanillaCpuLayout; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.Closeable; import java.io.File; import java.util.Arrays; import java.util.BitSet; /** * This utility class support locking a thread to a single core, or reserving a whole core for a * thread. * * @author peter.lawrey */ public class AffinityLock implements Closeable { // Static fields and methods. public static final String AFFINITY_RESERVED = "affinity.reserved"; // TODO It seems like on virtualized platforms .availableProcessors() value can change at // TODO runtime. We should think about how to adopt to such change public static final int PROCESSORS; public static final BitSet BASE_AFFINITY; public static final BitSet RESERVED_AFFINITY; static final int ANY_CPU = -1; private static final Logger LOGGER = LoggerFactory.getLogger(AffinityLock.class); private static final LockInventory LOCK_INVENTORY; static { int processors = Runtime.getRuntime().availableProcessors(); VanillaCpuLayout cpuLayout = null; try { if (new File("/proc/cpuinfo").exists()) { cpuLayout = VanillaCpuLayout.fromCpuInfo(); processors = cpuLayout.cpus(); } } catch (Throwable e) { LOGGER.warn("Unable to load /proc/cpuinfo", e); } PROCESSORS = processors; BASE_AFFINITY = Affinity.getAffinity(); RESERVED_AFFINITY = getReservedAffinity0(); LOCK_INVENTORY = new LockInventory(cpuLayout == null ? new NoCpuLayout(PROCESSORS) : cpuLayout); } /** * Logical ID of the CPU to which this lock belongs to. */ private final int cpuId; /** * CPU to which this lock belongs to is of general use. */ private final boolean base; /** * CPU to which this lock belongs to is reservable. */ private final boolean reservable; /** * An inventory build from the CPU layout which keeps track of the various locks belonging to * each CPU. */ private final LockInventory lockInventory; boolean bound = false; @Nullable Thread assignedThread; Throwable boundHere; private boolean resetAffinity = true; AffinityLock(int cpuId, boolean base, boolean reservable, LockInventory lockInventory) { this.lockInventory = lockInventory; this.cpuId = cpuId; this.base = base; this.reservable = reservable; } /** * Set the CPU layout for this machine. CPUs which are not mentioned will be ignored.

* Changing the layout will have no impact on thread which have already been assigned. It only * affects subsequent assignments. * * @param cpuLayout for this application to use for this machine. */ public static void cpuLayout(@NotNull CpuLayout cpuLayout) { LOCK_INVENTORY.set(cpuLayout); } /** * @return The current CpuLayout for the application. */ @NotNull public static CpuLayout cpuLayout() { return LOCK_INVENTORY.getCpuLayout(); } private static BitSet getReservedAffinity0() { String reservedAffinity = System.getProperty(AFFINITY_RESERVED); if (BASE_AFFINITY != null && (reservedAffinity == null || reservedAffinity.trim().isEmpty())) { BitSet reserverable = new BitSet(PROCESSORS); reserverable.set(1, PROCESSORS, true); reserverable.andNot(BASE_AFFINITY); if (reserverable.isEmpty() && PROCESSORS > 1) { // make all but first CPUs available reserverable.set(1, PROCESSORS); return reserverable; } return reserverable; } reservedAffinity = reservedAffinity.trim(); long[] longs = new long[1 + (reservedAffinity.length() - 1) / 16]; 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); end = begin; } return BitSet.valueOf(longs); } /** * Assign any free cpu to this thread. * * @return A handle for the current AffinityLock. */ 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.

In reality, only one cpu is assigned, the rest of * the threads for that core are reservable so they are not used. * * @return A handle for the current AffinityLock. */ public static AffinityLock acquireCore() { return acquireCore(true); } /** * Assign a cpu which can be bound to the current thread or another thread.

This can be used * for defining your thread layout centrally and passing the handle via dependency injection. * * @param bind if true, bind the current thread, if false, reserve a cpu which can be bound * later. * @return A handle for an affinity lock. */ public static AffinityLock acquireLock(boolean bind) { return acquireLock(bind, ANY_CPU, AffinityStrategies.ANY); } /** * Assign a cpu which can be bound to the current thread or another thread.

This can be used * for defining your thread layout centrally and passing the handle via dependency injection. * * @param cpuId the CPU id to bind to * @return A handle for an affinity lock. */ public static AffinityLock acquireLock(int cpuId) { return acquireLock(true, cpuId, AffinityStrategies.ANY); } /** * Assign a cpu which can be bound to the current thread or another thread * Caller passes in an explicit set of preferred CPUs * The first available CPU is used, and the lock returned * If all CPUs in the set are unavailable then no lock is obtained * * @param cpus the array of available CPUs to bind to * @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 ) { AffinityLock lock = tryAcquireLock(true, cpu); if(lock != null) { LOGGER.info("Acquired lock on CPU {}", cpu); return lock; } } LOGGER.warn("Failed to lock any CPU in explicit list " + Arrays.toString(cpus)); return LOCK_INVENTORY.noLock(); } /** * Allocate from the end. * * @param n positive number to allocate from. * @return the lock acquired */ public static AffinityLock acquireLockLastMinus(int n) { return acquireLock(true, PROCESSORS - n, AffinityStrategies.ANY); } /** * Use a description to allocate a cpu. *

    *
  • "N" being a positive integer means allocate this CPU,
    • *
  • "last" or "last-N" means allocate from the end,
    • *
  • "csv:1,2,5,6 eg means allocate first free core from the provided
    • *
  • "any" means allow any
    • *
  • "none" or null means
    • *
  • "0" is not allowed
    • *
* * @param desc of which cpu to pick * @return the AffinityLock obtained */ public static AffinityLock acquireLock(String desc) { if (desc == null) return LOCK_INVENTORY.noLock(); desc = desc.toLowerCase(); int cpuId; if (desc.startsWith("last")) { String last = desc.substring(4); int lastN; if (last.isEmpty()) lastN = 0; else try { lastN = Integer.parseInt(last); } catch (NumberFormatException e) { throw new IllegalArgumentException("Cannot parse '" + desc + "'", e); } if (lastN > 0) throw new IllegalArgumentException("Cannot parse '" + desc + "'"); cpuId = PROCESSORS + lastN - 1; } else if (desc.startsWith("csv:")) { String content = desc.substring(4); int[] cpus = Arrays.asList(content.split(",")).stream() .map(String::trim) .mapToInt(Integer::parseInt).toArray(); return acquireLock(cpus); } else if (desc.equals("none")) { return LOCK_INVENTORY.noLock(); } else if (desc.equals("any")) { return acquireLock(); } else { try { cpuId = Integer.parseInt(desc); } catch (NumberFormatException e) { throw new IllegalArgumentException("Cannot parse '" + desc + "'", e); } } if (cpuId <= 0) { System.err.println("Cannot allocate 0 or negative cpuIds '" + desc + "'"); return LOCK_INVENTORY.noLock(); } return acquireLock(cpuId); } /** * Assign a core(and all its cpus) which can be bound to the current thread or another thread. *

This can be used for defining your thread layout centrally and passing the handle via * dependency injection. * * @param bind if true, bind the current thread, if false, reserve a cpu which can be bound * later. * @return A handle for an affinity lock. */ public static AffinityLock acquireCore(boolean bind) { return acquireCore(bind, ANY_CPU, AffinityStrategies.ANY); } private static AffinityLock acquireLock(boolean bind, int cpuId, @NotNull AffinityStrategy... strategies) { Warnings.warmNoReservedCPUs(); return LOCK_INVENTORY.acquireLock(bind, cpuId, strategies); } /** * 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 cpuId - the cpu to lock * @return - A handle to an affinity lock on success; null if failed to lock */ private static AffinityLock tryAcquireLock(boolean bind, int cpuId) { return LOCK_INVENTORY.tryAcquireLock(bind, cpuId); } private static AffinityLock acquireCore(boolean bind, int cpuId, @NotNull AffinityStrategy... strategies) { Warnings.warmNoReservedCPUs(); return LOCK_INVENTORY.acquireCore(bind, cpuId, strategies); } /** * @return All the current locks as a String. */ @NotNull public static String dumpLocks() { return LOCK_INVENTORY.dumpLocks(); } private static boolean areAssertionsEnabled() { boolean debug = false; assert debug = true; return debug; } /** * @return Whether to reset the affinity, false indicates the thread is about to die anyway. */ public boolean resetAffinity() { return resetAffinity; } /** * @param resetAffinity Whether to reset the affinity, false indicates the thread is about to die anyway. * @return this */ public AffinityLock resetAffinity(boolean resetAffinity) { this.resetAffinity = resetAffinity; return this; } /** * Assigning the current thread has a side effect of preventing the lock being used again until * it is released. * * @param bind whether to bind the thread as well * @param wholeCore whether to reserve all the thread in the same core. */ final void assignCurrentThread(boolean bind, boolean wholeCore) { assignedThread = Thread.currentThread(); if (bind) bind(wholeCore); } /** * Bind the current thread to this reservable lock. */ public void bind() { bind(false); } /** * Bind the current thread to this reservable lock. * * @param wholeCore if true, also reserve the whole core. */ public void bind(boolean wholeCore) { if (bound && assignedThread != null && assignedThread.isAlive()) throw new IllegalStateException("cpu " + cpuId + " already bound to " + assignedThread); if (areAssertionsEnabled()) boundHere = new Throwable("Bound here"); if (wholeCore) { lockInventory.bindWholeCore(cpuId); } else if (cpuId >= 0) { bound = true; assignedThread = Thread.currentThread(); LOGGER.info("Assigning cpu {} to {} on thread id {}", cpuId, assignedThread, Affinity.getThreadId()); } if (cpuId >= 0) { BitSet affinity = new BitSet(); affinity.set(cpuId, true); Affinity.setAffinity(affinity); } } final boolean canReserve(boolean specified) { if (!specified && !reservable) return false; if (!LockCheck.isCpuFree(cpuId)) return false; if (assignedThread != null) { if (assignedThread.isAlive()) { return false; } LOGGER.warn("Lock assigned to {} but this thread is dead.", assignedThread); } return true; } /** * Give another affinity lock relative to this one based on a list of strategies.

The * strategies are evaluated in order to (like a search path) to find the next appropriate * thread. If ANY is not the last strategy, a warning is logged and no cpu is assigned (leaving * the OS to choose) * * @param strategies To determine if you want the same/different core/socket. * @return A matching AffinityLock. */ public AffinityLock acquireLock(AffinityStrategy... strategies) { return acquireLock(false, cpuId, strategies); } /** * Release the current AffinityLock which can be discarded. */ public void release() { if (cpuId == ANY_CPU) return; // expensive if not actually used. boolean resetAffinity = this.resetAffinity; this.resetAffinity = true; lockInventory.release(resetAffinity); } @Override public void close() { release(); } @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); release(); } super.finalize(); } /** * @return unique id for this CPI or -1 if not allocated. */ public int cpuId() { return cpuId; } /** * @return Was a cpu found to bind this lock to. */ public boolean isAllocated() { return cpuId >= 0; } /** * @return Has this AffinityLock been bound? */ public boolean isBound() { return bound; } @Override public String toString() { StringBuilder sb = new StringBuilder(); if (assignedThread != null) sb.append(assignedThread).append(" alive=").append(assignedThread.isAlive()); else if (reservable) sb.append("Reserved for this application"); else if (base) sb.append("General use CPU"); else sb.append("CPU not available"); return sb.toString(); } } AffinityStrategies.java000066400000000000000000000046201435750131000361720ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * Pre-defined strategies for determining which thread to pick next. * * @author peter.lawrey */ public enum AffinityStrategies implements AffinityStrategy { /** * Any free cpu. */ ANY { @Override public boolean matches(int cpuId, int cpuId2) { return true; } }, /** * Must be a cpu on the same core. */ SAME_CORE { @Override public boolean matches(int cpuId, int cpuId2) { CpuLayout cpuLayout = AffinityLock.cpuLayout(); return cpuLayout.socketId(cpuId) == cpuLayout.socketId(cpuId2) && cpuLayout.coreId(cpuId) == cpuLayout.coreId(cpuId2); } }, /** * Must be a cpu on the same socket/chip but different core. */ SAME_SOCKET { @Override public boolean matches(int cpuId, int cpuId2) { CpuLayout cpuLayout = AffinityLock.cpuLayout(); return cpuLayout.socketId(cpuId) == cpuLayout.socketId(cpuId2) && cpuLayout.coreId(cpuId) != cpuLayout.coreId(cpuId2); } }, /** * Must be a cpu on any other core (or socket) */ DIFFERENT_CORE { @Override public boolean matches(int cpuId, int cpuId2) { CpuLayout cpuLayout = AffinityLock.cpuLayout(); return cpuLayout.socketId(cpuId) != cpuLayout.socketId(cpuId2) || cpuLayout.coreId(cpuId) != cpuLayout.coreId(cpuId2); } }, /** * Must be a cpu on any other socket. */ DIFFERENT_SOCKET { @Override public boolean matches(int cpuId, int cpuId2) { CpuLayout cpuLayout = AffinityLock.cpuLayout(); return cpuLayout.socketId(cpuId) != cpuLayout.socketId(cpuId2); } } } AffinityStrategy.java000066400000000000000000000017371435750131000356700ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * Allow you define a strategy for find the a cpu relative to another select cpu. * * @author peter.lawrey */ public interface AffinityStrategy { /** * @param cpuId to cpuId to compare * @param cpuId2 with a second cpuId * @return true if it matches the criteria. */ boolean matches(int cpuId, int cpuId2); } AffinitySupport.java000066400000000000000000000016521435750131000355360ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * For backward compatibility with Affinity 2.x */ @Deprecated(/* to be removed in x.22 */) public class AffinitySupport { public static int getThreadId() { return Affinity.getThreadId(); } public static void setThreadId() { Affinity.setThreadId(); } } AffinityThreadFactory.java000066400000000000000000000045731435750131000366260ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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 org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.concurrent.ThreadFactory; /** * This is a ThreadFactory which assigns threads based the strategies provided. *

* If no strategies are provided AffinityStrategies.ANY is used. * * @author peter.lawrey */ public class AffinityThreadFactory implements ThreadFactory { private final String name; private final boolean daemon; @NotNull private final AffinityStrategy[] strategies; @Nullable private AffinityLock lastAffinityLock = null; private int id = 1; public AffinityThreadFactory(String name, AffinityStrategy... strategies) { this(name, true, strategies); } public AffinityThreadFactory(String name, boolean daemon, @NotNull AffinityStrategy... strategies) { this.name = name; this.daemon = daemon; this.strategies = strategies.length == 0 ? new AffinityStrategy[]{AffinityStrategies.ANY} : strategies; } @NotNull @Override 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()) { r.run(); } } }, name2); t.setDaemon(daemon); return t; } private synchronized AffinityLock acquireLockBasedOnLast() { AffinityLock al = lastAffinityLock == null ? AffinityLock.acquireLock(false) : lastAffinityLock.acquireLock(strategies); al.bind(); if (al.cpuId() >= 0) lastAffinityLock = al; return al; } } BootClassPath.java000066400000000000000000000074671435750131000351100ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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 org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.nio.file.*; import java.nio.file.attribute.BasicFileAttributes; import java.util.Collections; import java.util.Enumeration; import java.util.HashSet; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; enum BootClassPath { INSTANCE; private final Set bootClassPathResources = Collections.unmodifiableSet(getResourcesOnBootClasspath()); private static Set getResourcesOnBootClasspath() { final Logger logger = LoggerFactory.getLogger(BootClassPath.class); final Set resources = new HashSet<>(); final String bootClassPath = System.getProperty("sun.boot.class.path", ""); logger.trace("Boot class-path is: {}", bootClassPath); final String pathSeparator = System.getProperty("path.separator"); logger.trace("Path separator is: '{}'", pathSeparator); final String[] pathElements = bootClassPath.split(pathSeparator); for (final String pathElement : pathElements) { resources.addAll(findResources(Paths.get(pathElement), logger)); } return resources; } private static Set findResources(final Path path, final Logger logger) { if (!Files.exists(path)) { return Collections.emptySet(); } if (Files.isDirectory(path)) { return findResourcesInDirectory(path, logger); } return findResourcesInJar(path, logger); } private static Set findResourcesInJar(final Path path, final Logger logger) { final Set jarResources = new HashSet<>(); try (final JarFile jarFile = new JarFile(path.toFile())) { final Enumeration entries = jarFile.entries(); while (entries.hasMoreElements()) { final JarEntry jarEntry = entries.nextElement(); if (jarEntry.getName().endsWith(".class")) { jarResources.add(jarEntry.getName()); } } } catch (IOException e) { logger.warn("Not a jar file: {}", path); } return jarResources; } private static Set findResourcesInDirectory(final Path path, final Logger logger) { final Set dirResources = new HashSet<>(); try { Files.walkFileTree(path, new SimpleFileVisitor() { @Override public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException { if (file.getFileName().toString().endsWith(".class")) { dirResources.add(path.relativize(file).toString()); } return super.visitFile(file, attrs); } }); } catch (IOException e) { logger.warn("Error walking dir: " + path, e); } return dirResources; } public final boolean has(String binaryClassName) { final String resourceClassName = binaryClassName.replace('.', '/').concat(".class"); return bootClassPathResources.contains(resourceClassName); } } CpuLayout.java000066400000000000000000000024101435750131000343060ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * @author peter.lawrey */ public interface CpuLayout { /** * @return the number of cpus. */ int cpus(); int sockets(); int coresPerSocket(); int threadsPerCore(); /** * @param cpuId the logical processor number * @return which socket id this cpu is on. */ int socketId(int cpuId); /** * @param cpuId the logical processor number * @return which core on a socket this cpu is on. */ int coreId(int cpuId); /** * @param cpuId the logical processor number * @return which thread on a core this cpu is on. */ int threadId(int cpuId); } IAffinity.java000066400000000000000000000025021435750131000342450ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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 java.util.BitSet; /** * Implementation interface * * @author cheremin * @since 29.12.11, 20:14 */ public interface IAffinity { /** * @return returns affinity mask for current thread, or null if unknown */ BitSet getAffinity(); /** * @param affinity sets affinity mask of current thread to specified value */ void setAffinity(final BitSet affinity); /** * @return the current cpu id, or -1 if unknown. */ int getCpu(); /** * @return the process id of the current process. */ int getProcessId(); /** * @return the thread id of the current thread or -1 is not available. */ int getThreadId(); } LockCheck.java000066400000000000000000000061511435750131000342150ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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.lockchecker.FileLockBasedLockChecker; import net.openhft.affinity.lockchecker.LockChecker; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; /** * @author Rob Austin. */ public enum LockCheck { ; // none private static final Logger LOGGER = LoggerFactory.getLogger(LockCheck.class); private static final String OS = System.getProperty("os.name").toLowerCase(); static final boolean IS_LINUX = OS.startsWith("linux"); private static final int EMPTY_PID = Integer.MIN_VALUE; 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]); } static boolean canOSSupportOperation() { return IS_LINUX; } public static boolean isCpuFree(int cpu) { if (!canOSSupportOperation()) return true; return isLockFree(cpu); } static boolean replacePid(int cpu, long processID) throws IOException { return storePid(processID, cpu); } public static boolean isProcessRunning(long pid) { if (canOSSupportOperation()) return new File("/proc/" + pid).exists(); else throw new UnsupportedOperationException("this is only supported on LINUX"); } /** * 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 isLockFree(int id) { return lockChecker.isLockFree(id); } public static int getProcessForCpu(int core) throws IOException { String meta = lockChecker.getMetaInfo(core); if (meta != null && !meta.isEmpty()) { try { return Integer.parseInt(meta); } catch (NumberFormatException e) { //nothing } } return EMPTY_PID; } static boolean updateCpu(int cpu) throws IOException { if (!canOSSupportOperation()) return true; return replacePid(cpu, getPID()); } public static void releaseLock(int cpu) { lockChecker.releaseLock(cpu); } }LockInventory.java000066400000000000000000000245731435750131000352050ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2016-2020 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.NullAffinity; import org.jetbrains.annotations.NotNull; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.nio.channels.ClosedByInterruptException; import java.util.NavigableMap; import java.util.TreeMap; import static net.openhft.affinity.Affinity.getAffinityImpl; class LockInventory { private static final Logger LOGGER = LoggerFactory.getLogger(LockInventory.class); /** * The locks belonging to physical cores. Since a physical core can host multiple logical cores * the relationship is one to many. */ private final NavigableMap physicalCoreLocks = new TreeMap<>(); private CpuLayout cpuLayout; /** * The lock belonging to each logical core. 1-to-1 relationship */ private AffinityLock[] logicalCoreLocks; public LockInventory(CpuLayout cpuLayout) { set(cpuLayout); } public static String dumpLocks(@NotNull AffinityLock[] locks) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < locks.length; i++) { AffinityLock al = locks[i]; sb.append(i).append(": "); sb.append(al.toString()); sb.append('\n'); } return sb.toString(); } private static boolean anyStrategyMatches(final int cpuOne, final int cpuTwo, final AffinityStrategy[] strategies) { for (AffinityStrategy strategy : strategies) { if (strategy.matches(cpuOne, cpuTwo)) { return true; } } return false; } private static boolean isAnyCpu(final int cpuId) { return cpuId == AffinityLock.ANY_CPU; } /** * Update the lock for the current thread * * @param bind Whether to also bind the thread to the core * @param al The lock to update * @param wholeCore Whether to bind the whole core * @return true if the lock was acquired, false otherwise */ private static boolean updateLockForCurrentThread(final boolean bind, final AffinityLock al, final boolean wholeCore) throws ClosedByInterruptException { try { if (LockCheck.updateCpu(al.cpuId())) { al.assignCurrentThread(bind, wholeCore); return true; } } catch (ClosedByInterruptException e) { throw e; } catch (IOException e) { LOGGER.warn("Error occurred acquiring lock", e); } return false; } public final synchronized CpuLayout getCpuLayout() { return cpuLayout; } public final synchronized void set(CpuLayout cpuLayout) { if (cpuLayout.equals(this.cpuLayout)) { return; } reset(cpuLayout); for (int i = 0; i < cpuLayout.cpus(); i++) { final boolean base = AffinityLock.BASE_AFFINITY.get(i); final boolean reservable = AffinityLock.RESERVED_AFFINITY.get(i); LOGGER.trace("cpu {} base={} reservable= {}", i, base, reservable); AffinityLock lock = logicalCoreLocks[i] = newLock(i, base, reservable); int layoutId = lock.cpuId(); int physicalCore = toPhysicalCore(layoutId); AffinityLock[] locks = physicalCoreLocks.get(physicalCore); if (locks == null) { physicalCoreLocks.put(physicalCore, locks = new AffinityLock[cpuLayout.threadsPerCore()]); } locks[cpuLayout.threadId(layoutId)] = lock; } } public final synchronized AffinityLock acquireLock(boolean bind, int cpuId, AffinityStrategy... strategies) { if (getAffinityImpl() instanceof NullAffinity) return noLock(); final boolean specificCpuRequested = !isAnyCpu(cpuId); try { if (specificCpuRequested && cpuId != 0) { if (cpuId > logicalCoreLocks.length) { LOGGER.warn("Unable to acquire lock on CPU {} for thread {}, as not enough CPUs", cpuId, Thread.currentThread()); return noLock(); } final AffinityLock required = logicalCoreLocks[cpuId]; if (required.canReserve(true) && anyStrategyMatches(cpuId, cpuId, strategies) && updateLockForCurrentThread(bind, required, false)) { return required; } LOGGER.warn("Unable to acquire lock on CPU {} for thread {}, trying to find another CPU", cpuId, Thread.currentThread()); } for (AffinityStrategy strategy : strategies) { // consider all processors except cpu 0 which is usually used by the OS. // if you have only one core, this library is not appropriate in any case. for (int i = logicalCoreLocks.length - 1; i > 0; i--) { AffinityLock al = logicalCoreLocks[i]; if (al.canReserve(false) && (isAnyCpu(cpuId) || strategy.matches(cpuId, al.cpuId())) && updateLockForCurrentThread(bind, al, false)) { return al; } } } } catch (ClosedByInterruptException e) { Thread.currentThread().interrupt(); return noLock(); } LOGGER.warn("No reservable CPU for {}", Thread.currentThread()); return noLock(); } public final synchronized AffinityLock tryAcquireLock(boolean bind, int cpuId) { if (getAffinityImpl() instanceof NullAffinity) return null; if (cpuId > logicalCoreLocks.length) return null; final AffinityLock required = logicalCoreLocks[cpuId]; try { if (required.canReserve(true) && updateLockForCurrentThread(bind, required, false)) { return required; } } catch (ClosedByInterruptException e) { Thread.currentThread().interrupt(); return noLock(); } LOGGER.warn("Unable to acquire lock on CPU {} for thread {}, trying to find another CPU", cpuId, Thread.currentThread()); return null; } public final synchronized AffinityLock acquireCore(boolean bind, int cpuId, AffinityStrategy... strategies) { for (AffinityStrategy strategy : strategies) { LOOP: for (AffinityLock[] als : physicalCoreLocks.descendingMap().values()) { for (AffinityLock al : als) if (!al.canReserve(false) || !strategy.matches(cpuId, al.cpuId())) continue LOOP; final AffinityLock al = als[0]; try { if (updateLockForCurrentThread(bind, al, true)) { return al; } } catch (ClosedByInterruptException e) { Thread.currentThread().interrupt(); return noLock(); } } } LOGGER.warn("No reservable Core for {}", Thread.currentThread()); return acquireLock(bind, cpuId, strategies); } public final synchronized void bindWholeCore(int logicalCoreID) { if (logicalCoreID < 0) { LOGGER.warn("Can't bind core since it was not possible to reserve it!"); return; } int core = toPhysicalCore(logicalCoreID); for (AffinityLock al : physicalCoreLocks.get(core)) { if (al.isBound() && al.assignedThread != null && al.assignedThread.isAlive()) { LOGGER.warn("cpu {} already bound to {}", al.cpuId(), al.assignedThread); } else { al.bound = true; al.assignedThread = Thread.currentThread(); } } if (LOGGER.isInfoEnabled()) { StringBuilder sb = new StringBuilder().append("Assigning core ").append(core); String sep = ": cpus "; for (AffinityLock al : physicalCoreLocks.get(core)) { sb.append(sep).append(al.cpuId()); sep = ", "; } sb.append(" to ").append(Thread.currentThread()); LOGGER.info(sb.toString()); } } public final synchronized void release(boolean resetAffinity) { Thread t = Thread.currentThread(); for (AffinityLock al : logicalCoreLocks) { Thread at = al.assignedThread; if (at == t) { releaseAffinityLock(t, al, "Releasing cpu {} from {}"); } else if (at != null && !at.isAlive()) { releaseAffinityLock(t, al, "Releasing cpu {} from {} as it is not alive."); } } if (resetAffinity) Affinity.resetToBaseAffinity(); } public final synchronized String dumpLocks() { return dumpLocks(logicalCoreLocks); } protected AffinityLock newLock(int cpuId, boolean base, boolean reservable) { return new AffinityLock(cpuId, base, reservable, this); } private void reset(CpuLayout cpuLayout) { this.cpuLayout = cpuLayout; this.logicalCoreLocks = new AffinityLock[cpuLayout.cpus()]; this.physicalCoreLocks.clear(); } private int toPhysicalCore(int layoutId) { return cpuLayout.socketId(layoutId) * cpuLayout.coresPerSocket() + cpuLayout.coreId(layoutId); } private void releaseAffinityLock(final Thread t, final AffinityLock al, final String format) { LOGGER.info(format, al.cpuId(), t); al.assignedThread = null; al.bound = false; al.boundHere = null; LockCheck.releaseLock(al.cpuId()); } public AffinityLock noLock() { return newLock(AffinityLock.ANY_CPU, false, false); } } MicroJitterSampler.java000066400000000000000000000132171435750131000361470ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/* * Copyright 2014 Higher Frequency Trading * * https://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 java.io.PrintStream; /** * User: peter.lawrey Date: 30/06/13 Time: 13:13 */ public class MicroJitterSampler { private static final long[] DELAY = { 2 * 1000, 3 * 1000, 4 * 1000, 6 * 1000, 8 * 1000, 10 * 1000, 14 * 1000, 20 * 1000, 30 * 1000, 40 * 1000, 60 * 1000, 80 * 1000, 100 * 1000, 140 * 1000, 200 * 1000, 300 * 1000, 400 * 1000, 600 * 1000, 800 * 1000, 1000 * 1000, 2 * 1000 * 1000, 5 * 1000 * 1000, 10 * 1000 * 1000, 20 * 1000 * 1000, 50 * 1000 * 1000, 100 * 1000 * 1000 }; private static final double UTIL = Double.parseDouble(System.getProperty("util", "50")); private static final boolean BUSYWAIT = Boolean.parseBoolean(System.getProperty("busywait", "false")); private static final String CPU = System.getProperty("cpu", "none"); private final int[] count = new int[DELAY.length]; private long totalTime = 0; private static void pause() throws InterruptedException { if (BUSYWAIT) { long now = System.nanoTime(); while (System.nanoTime() - now < 1_000_000) ; } else { Thread.sleep(1); } } public static void main(String... ignored) throws InterruptedException { MicroJitterSampler sampler = new MicroJitterSampler(); Thread t = new Thread(sampler::run); t.start(); t.join(); } private void once() throws InterruptedException { if (UTIL >= 100) { sample(30L * 1000 * 1000 * 1000); } else { long sampleLength = (long) ((1 / (1 - UTIL / 100) - 1) * 1000 * 1000); for (int i = 0; i < 30 * 1000; i += 2) { sample(sampleLength); //noinspection BusyWait pause(); } } } public void run() { try (final AffinityLock lock = AffinityLock.acquireLock(CPU)) { boolean first = true; System.out.println("Warming up..."); while (!Thread.currentThread().isInterrupted()) { once(); if (first) { reset(); first = false; System.out.println("Warmup complete. Running jitter tests..."); continue; } print(System.out); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } 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; totalTime = 0; } void sample(long intervalNS) { long prev = System.nanoTime(); long end = prev + intervalNS; long now; do { now = System.nanoTime(); long time = now - prev; if (time >= DELAY[0]) { int i; for (i = 1; i < DELAY.length; i++) if (time < DELAY[i]) break; count[i - 1]++; } prev = now; } while (now < end); totalTime += intervalNS; } void print(PrintStream ps) { ps.println("After " + totalTime / 1000000000 + " seconds, the average per hour was"); for (int i = 0; i < DELAY.length; i++) { if (count[i] < 1) continue; long countPerHour = (long) Math.ceil(count[i] * 3600e9 / totalTime); ps.println(asString(DELAY[i]) + '\t' + countPerHour); } ps.println(); } } /* e.g. Ubuntu 20.04, Ryzen 5950X with an isolated CPU. (init 3) sudo cpupower -c {cpu} -g performance, run from command line After 3600 seconds, the average per hour was 2us 2571 3us 2304 4us 376 6us 1 10us 1 20us 1 30us 1 40us 2 60us 1 Ubuntu 20.04, Ryzen 5950X with an isolated CPU. (init 5) sudo cpupower -c {cpu} -g performance, run from command line After 3600 seconds, the average per hour was 2us 2157 3us 3444 4us 3654 6us 135 8us 4 14us 1 20us 1 40us 2 60us 1 Ubuntu 20.04, Ryzen 5950X with an isolated CPU. (init 5) sudo cpupower -c {cpu} -g performance, run from IntelliJ CE After 7200 seconds, the average per hour was 2us 2189 3us 3341 4us 2335 6us 191 8us 4 14us 1 20us 1 Windows 10 i7-4770 laptop After 1845 seconds, the average per hour was 2us 2435969 3us 548812 4us 508041 6us 60320 8us 25374 10us 1832324 14us 2089216 20us 391901 30us 16063 40us 6440 60us 2617 80us 1487 100us 1241 140us 826 200us 2108 300us 601 400us 159 600us 129 800us 215 1ms 155 2ms 229 5ms 24 10ms 38 20ms 32 On an Centos 7 machine with an isolated CPU. After 2145 seconds, the average per hour was 2us 781271 3us 1212123 4us 13504 6us 489 8us 2 10us 3032577 14us 17475 20us 628 30us 645 40us 1301 60us 1217 80us 1306 100us 1526 140us 22 */ Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/000077500000000000000000000000001435750131000325415ustar00rootroot00000000000000LinuxHelper.java000066400000000000000000000271501435750131000355710ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.*; import com.sun.jna.ptr.IntByReference; import org.jetbrains.annotations.NotNull; import java.util.Arrays; import java.util.BitSet; import java.util.Collections; import java.util.List; public class LinuxHelper { private static final String LIBRARY_NAME = "c"; private static final VersionHelper UNKNOWN = new VersionHelper(0, 0, 0); private static final VersionHelper VERSION_2_6 = new VersionHelper(2, 6, 0); private static final VersionHelper version; static { final utsname uname = new utsname(); VersionHelper ver = UNKNOWN; try { if (CLibrary.INSTANCE.uname(uname) == 0) { ver = new VersionHelper(uname.getRealeaseVersion()); } } catch (Throwable e) { //Jvm.warn().on(getClass(), "Failed to determine Linux version: " + e); } version = ver; } public static @NotNull cpu_set_t sched_getaffinity() { final CLibrary lib = CLibrary.INSTANCE; final cpu_set_t cpuset = new cpu_set_t(); final int size = version.isSameOrNewer(VERSION_2_6) ? cpu_set_t.SIZE_OF_CPU_SET_T : NativeLong.SIZE; try { if (lib.sched_getaffinity(0, size, cpuset) != 0) { throw new IllegalStateException("sched_getaffinity(0, " + size + ", cpuset) failed; errno=" + Native.getLastError()); } } catch (LastErrorException e) { throw new IllegalStateException("sched_getaffinity(0, (" + size + ") , cpuset) failed; errno=" + e.getErrorCode(), e); } return cpuset; } 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; final cpu_set_t cpuset = new cpu_set_t(); final int size = version.isSameOrNewer(VERSION_2_6) ? cpu_set_t.SIZE_OF_CPU_SET_T : NativeLong.SIZE; final long[] bits = affinity.toLongArray(); for (int i = 0; i < bits.length; i++) { if (Platform.is64Bit()) { cpuset.__bits[i].setValue(bits[i]); } else { cpuset.__bits[i * 2].setValue(bits[i] & 0xFFFFFFFFL); cpuset.__bits[i * 2 + 1].setValue((bits[i] >>> 32) & 0xFFFFFFFFL); } } try { if (lib.sched_setaffinity(pid, size, cpuset) != 0) { throw new IllegalStateException("sched_setaffinity(" + pid + ", " + size + ", 0x" + Utilities.toHexString(affinity) + ") failed; errno=" + Native.getLastError()); } } catch (LastErrorException e) { throw new IllegalStateException("sched_setaffinity(" + pid + ", " + size + ", 0x" + Utilities.toHexString(affinity) + ") failed; errno=" + e.getErrorCode(), e); } } public static int sched_getcpu() { final CLibrary lib = CLibrary.INSTANCE; try { final int ret = lib.sched_getcpu(); if (ret < 0) { throw new IllegalStateException("sched_getcpu() failed; errno=" + Native.getLastError()); } return ret; } catch (LastErrorException e) { throw new IllegalStateException("sched_getcpu() failed; errno=" + e.getErrorCode(), e); } catch (UnsatisfiedLinkError ule) { try { final IntByReference cpu = new IntByReference(); final IntByReference node = new IntByReference(); final int ret = lib.syscall(318, cpu, node, null); if (ret != 0) { throw new IllegalStateException("getcpu() failed; errno=" + Native.getLastError()); } return cpu.getValue(); } catch (LastErrorException lee) { if (lee.getErrorCode() == 38 && Platform.is64Bit()) { // unknown call final Pointer getcpuAddr = new Pointer((-10L << 20) + 1024L * 2L); final Function getcpu = Function.getFunction(getcpuAddr, Function.C_CONVENTION); final IntByReference cpu = new IntByReference(); if (getcpu.invokeInt(new Object[]{cpu, null, null}) < 0) { throw new IllegalStateException("getcpu() failed; errno=" + Native.getLastError()); } else { return cpu.getValue(); } } else { throw new IllegalStateException("getcpu() failed; errno=" + lee.getErrorCode(), lee); } } } } public static int getpid() { final CLibrary lib = CLibrary.INSTANCE; try { final int ret = lib.getpid(); if (ret < 0) { throw new IllegalStateException("getpid() failed; errno=" + Native.getLastError()); } return ret; } catch (LastErrorException e) { throw new IllegalStateException("getpid() failed; errno=" + e.getErrorCode(), e); } } public static int syscall(int number, Object... args) { final CLibrary lib = CLibrary.INSTANCE; try { final int ret = lib.syscall(number, args); if (ret < 0) { throw new IllegalStateException("sched_getcpu() failed; errno=" + Native.getLastError()); } return ret; } catch (LastErrorException e) { throw new IllegalStateException("sched_getcpu() failed; errno=" + e.getErrorCode(), e); } } interface CLibrary extends Library { CLibrary INSTANCE = Native.load(LIBRARY_NAME, CLibrary.class); int sched_setaffinity(final int pid, final int cpusetsize, final cpu_set_t cpuset) throws LastErrorException; int sched_getaffinity(final int pid, final int cpusetsize, final cpu_set_t cpuset) throws LastErrorException; int getpid() throws LastErrorException; int sched_getcpu() throws LastErrorException; int uname(final utsname name) throws LastErrorException; int syscall(int number, Object... args) throws LastErrorException; } /** * Structure describing the system and machine. */ public static class utsname extends Structure { public static final int _UTSNAME_LENGTH = 65; static List FIELD_ORDER = Arrays.asList( "sysname", "nodename", "release", "version", "machine", "domainname" ); /** * Name of the implementation of the operating system. */ public byte[] sysname = new byte[_UTSNAME_LENGTH]; /** * Name of this node on the network. */ public byte[] nodename = new byte[_UTSNAME_LENGTH]; /** * Current release level of this implementation. */ public byte[] release = new byte[_UTSNAME_LENGTH]; /** * Current version level of this release. */ public byte[] version = new byte[_UTSNAME_LENGTH]; /** * Name of the hardware type the system is running on. */ public byte[] machine = new byte[_UTSNAME_LENGTH]; /** * NIS or YP domain name */ public byte[] domainname = new byte[_UTSNAME_LENGTH]; static int length(final byte[] data) { int len = 0; final int datalen = data.length; while (len < datalen && data[len] != 0) len++; return len; } @Override protected List getFieldOrder() { return FIELD_ORDER; } public String getSysname() { return new String(sysname, 0, length(sysname)); } @SuppressWarnings({"UnusedDeclaration"}) public String getNodename() { return new String(nodename, 0, length(nodename)); } public String getRelease() { return new String(release, 0, length(release)); } public String getRealeaseVersion() { final String release = getRelease(); final int releaseLen = release.length(); int len = 0; for (; len < releaseLen; len++) { final char c = release.charAt(len); if (Character.isDigit(c) || c == '.') { continue; } break; } return release.substring(0, len); } public String getVersion() { return new String(version, 0, length(version)); } public String getMachine() { return new String(machine, 0, length(machine)); } @SuppressWarnings({"UnusedDeclaration"}) public String getDomainname() { return new String(domainname, 0, length(domainname)); } @Override public String toString() { return getSysname() + " " + getRelease() + " " + getVersion() + " " + getMachine(); } } 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 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++) { __bits[i] = new NativeLong(0); } } @SuppressWarnings({"UnusedDeclaration"}) public static void __CPU_ZERO(cpu_set_t cpuset) { for (NativeLong bits : cpuset.__bits) { bits.setValue(0L); } } public static int __CPUELT(int cpu) { return cpu / __NCPUBITS; } public static long __CPUMASK(int cpu) { return 1L << (cpu % __NCPUBITS); } @SuppressWarnings({"UnusedDeclaration"}) public static void __CPU_SET(int cpu, cpu_set_t cpuset) { cpuset.__bits[__CPUELT(cpu)].setValue( cpuset.__bits[__CPUELT(cpu)].longValue() | __CPUMASK(cpu)); } @SuppressWarnings({"UnusedDeclaration"}) public static void __CPU_CLR(int cpu, cpu_set_t cpuset) { cpuset.__bits[__CPUELT(cpu)].setValue( cpuset.__bits[__CPUELT(cpu)].longValue() & ~__CPUMASK(cpu)); } @SuppressWarnings({"UnusedDeclaration"}) public static boolean __CPU_ISSET(int cpu, cpu_set_t cpuset) { return (cpuset.__bits[__CPUELT(cpu)].longValue() & __CPUMASK(cpu)) != 0; } @Override protected List getFieldOrder() { return FIELD_ORDER; } } } LinuxJNAAffinity.java000066400000000000000000000056161435750131000364570ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.NativeLong; import com.sun.jna.Platform; import net.openhft.affinity.IAffinity; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.BitSet; public enum LinuxJNAAffinity implements IAffinity { INSTANCE; public static final boolean LOADED; private static final Logger LOGGER = LoggerFactory.getLogger(LinuxJNAAffinity.class); private static final int PROCESS_ID; private static final int SYS_gettid = Platform.isPPC() ? 207 : Platform.is64Bit() ? 186 : 224; private static final Object[] NO_ARGS = {}; private static final String OS = System.getProperty("os.name").toLowerCase(); private static final boolean IS_LINUX = OS.startsWith("linux"); static { int pid = -1; try { pid = LinuxHelper.getpid(); } catch (NoClassDefFoundError | Exception ignored) { } PROCESS_ID = pid; } static { boolean loaded = false; try { INSTANCE.getAffinity(); loaded = true; } catch (NoClassDefFoundError | UnsatisfiedLinkError e) { if (IS_LINUX) LOGGER.warn("Unable to load jna library {}", e); } LOADED = loaded; } private final ThreadLocal THREAD_ID = new ThreadLocal<>(); @Override public BitSet getAffinity() { final LinuxHelper.cpu_set_t cpuset = LinuxHelper.sched_getaffinity(); BitSet ret = new BitSet(LinuxHelper.cpu_set_t.__CPU_SETSIZE); int i = 0; for (NativeLong nl : cpuset.__bits) { for (int j = 0; j < Long.SIZE; j++) ret.set(i++, ((nl.longValue() >>> j) & 1) != 0); } return ret; } // TODO: FIXME!!! CHANGE IAffinity TO SUPPORT PLATFORMS WITH 64+ CORES FIXME!!! @Override public void setAffinity(final BitSet affinity) { LinuxHelper.sched_setaffinity(affinity); } @Override public int getCpu() { return LinuxHelper.sched_getcpu(); } @Override public int getProcessId() { return PROCESS_ID; } @Override public int getThreadId() { Integer tid = THREAD_ID.get(); if (tid == null) THREAD_ID.set(tid = LinuxHelper.syscall(SYS_gettid, NO_ARGS)); return tid; } } NoCpuLayout.java000066400000000000000000000026411435750131000355520ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.CpuLayout; /** * This assumes there is one socket with every cpu on a different core. * * @author peter.lawrey */ public class NoCpuLayout implements CpuLayout { private final int cpus; public NoCpuLayout(int cpus) { this.cpus = cpus; } @Override public int sockets() { return 1; } @Override public int coresPerSocket() { return cpus; } @Override public int threadsPerCore() { return 1; } public int cpus() { return cpus; } @Override public int socketId(int cpuId) { return 0; } @Override public int coreId(int cpuId) { return cpuId; } @Override public int threadId(int cpuId) { return 0; } } NullAffinity.java000066400000000000000000000031471435750131000357360ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.IAffinity; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.lang.management.ManagementFactory; import java.util.BitSet; /** * @author peter.lawrey */ public enum NullAffinity implements IAffinity { INSTANCE; private static final Logger LOGGER = LoggerFactory.getLogger(NullAffinity.class); @Override public BitSet getAffinity() { return new BitSet(); } @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)); } @Override public int getCpu() { return -1; } @Override public int getProcessId() { final String name = ManagementFactory.getRuntimeMXBean().getName(); return Integer.parseInt(name.split("@")[0]); } @Override public int getThreadId() { throw new UnsupportedOperationException(); } } OSXJNAAffinity.java000066400000000000000000000044731435750131000360310ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.LastErrorException; import com.sun.jna.Library; import com.sun.jna.Native; import net.openhft.affinity.IAffinity; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.lang.management.ManagementFactory; import java.util.BitSet; /** * This is essentially the same as the NullAffinity implementation but with concrete * support for getThreadId(). * * @author daniel.shaya */ public enum OSXJNAAffinity implements IAffinity { INSTANCE; private static final Logger LOGGER = LoggerFactory.getLogger(OSXJNAAffinity.class); private final ThreadLocal THREAD_ID = new ThreadLocal<>(); @Override public BitSet getAffinity() { return new BitSet(); } @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)); } @Override public int getCpu() { return -1; } @Override public int getProcessId() { final String name = ManagementFactory.getRuntimeMXBean().getName(); return Integer.parseInt(name.split("@")[0]); } @Override public int getThreadId() { Integer tid = THREAD_ID.get(); if (tid == null) { tid = CLibrary.INSTANCE.pthread_self(); //The tid assumed to be an unsigned 24 bit, see net.openhft.lang.Jvm.getMaxPid() tid = tid & 0xFFFFFF; THREAD_ID.set(tid); } return tid; } interface CLibrary extends Library { CLibrary INSTANCE = Native.load("libpthread.dylib", CLibrary.class); int pthread_self() throws LastErrorException; } } PosixJNAAffinity.java000066400000000000000000000200571435750131000364560ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.*; import com.sun.jna.ptr.IntByReference; import com.sun.jna.ptr.PointerByReference; import net.openhft.affinity.IAffinity; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.nio.ByteBuffer; import java.util.Arrays; import java.util.BitSet; /** * Implementation of {@link IAffinity} based on JNA call of * sched_setaffinity(3)/sched_getaffinity(3) from 'c' library. Applicable for most * linux/unix platforms *

* TODO Support assignment to core 64 and above * * @author peter.lawrey * @author BegemoT */ public enum PosixJNAAffinity implements IAffinity { INSTANCE; public static final boolean LOADED; private static final Logger LOGGER = LoggerFactory.getLogger(PosixJNAAffinity.class); private static final String LIBRARY_NAME = Platform.isWindows() ? "msvcrt" : "c"; private static final int PROCESS_ID; private static final int SYS_gettid = Utilities.is64Bit() ? 186 : 224; private static final Object[] NO_ARGS = {}; static { int processId; try { processId = CLibrary.INSTANCE.getpid(); } catch (Exception ignored) { processId = -1; } PROCESS_ID = processId; } static { boolean loaded = false; try { INSTANCE.getAffinity(); loaded = true; } catch (UnsatisfiedLinkError e) { LOGGER.warn("Unable to load jna library {}", e); } LOADED = loaded; } private final ThreadLocal THREAD_ID = new ThreadLocal<>(); @Override public BitSet getAffinity() { final CLibrary lib = CLibrary.INSTANCE; final int procs = Runtime.getRuntime().availableProcessors(); final int cpuSetSizeInLongs = (procs + 63) / 64; final int cpuSetSizeInBytes = cpuSetSizeInLongs * 8; final Memory cpusetArray = new Memory(cpuSetSizeInBytes); final PointerByReference cpuset = new PointerByReference(cpusetArray); try { final int ret = lib.sched_getaffinity(0, cpuSetSizeInBytes, cpuset); if (ret < 0) { throw new IllegalStateException("sched_getaffinity((" + cpuSetSizeInBytes + ") , &(" + cpusetArray + ") ) return " + ret); } ByteBuffer buff = cpusetArray.getByteBuffer(0, cpuSetSizeInBytes); return BitSet.valueOf(buff.array()); } catch (LastErrorException e) { if (e.getErrorCode() != 22) { throw new IllegalStateException("sched_getaffinity((" + cpuSetSizeInBytes + ") , &(" + cpusetArray + ") ) errorNo=" + e.getErrorCode(), e); } } // fall back to the old method final IntByReference cpuset32 = new IntByReference(0); try { final int ret = lib.sched_getaffinity(0, Integer.SIZE / 8, cpuset32); if (ret < 0) { throw new IllegalStateException("sched_getaffinity((" + Integer.SIZE / 8 + ") , &(" + cpuset32 + ") ) return " + ret); } long[] longs = new long[1]; longs[0] = cpuset32.getValue() & 0xFFFFFFFFL; return BitSet.valueOf(longs); } catch (LastErrorException e) { throw new IllegalStateException("sched_getaffinity((" + Integer.SIZE / 8 + ") , &(" + cpuset32 + ") ) errorNo=" + e.getErrorCode(), e); } } @Override public void setAffinity(final BitSet affinity) { int procs = Runtime.getRuntime().availableProcessors(); if (affinity.isEmpty()) { throw new IllegalArgumentException("Cannot set zero affinity"); } final CLibrary lib = CLibrary.INSTANCE; byte[] buff = affinity.toByteArray(); final int cpuSetSizeInBytes = buff.length; final Memory cpusetArray = new Memory(cpuSetSizeInBytes); try { cpusetArray.write(0, buff, 0, buff.length); final int ret = lib.sched_setaffinity(0, cpuSetSizeInBytes, new PointerByReference(cpusetArray)); if (ret < 0) { throw new IllegalStateException("sched_setaffinity((" + cpuSetSizeInBytes + ") , &(" + affinity + ") ) return " + ret); } } catch (LastErrorException e) { if (e.getErrorCode() != 22 || !Arrays.equals(buff, cpusetArray.getByteArray(0, cpuSetSizeInBytes))) { throw new IllegalStateException("sched_setaffinity((" + cpuSetSizeInBytes + ") , &(" + affinity + ") ) errorNo=" + e.getErrorCode(), e); } } final int value = (int) affinity.toLongArray()[0]; if (value == 0) { throw new IllegalArgumentException("Cannot set zero affinity"); } final IntByReference cpuset32 = new IntByReference(0); cpuset32.setValue(value); try { final int ret = lib.sched_setaffinity(0, Integer.SIZE / 8, cpuset32); if (ret < 0) throw new IllegalStateException("sched_setaffinity((" + Integer.SIZE / 8 + ") , &(" + Integer.toHexString(cpuset32.getValue()) + ") ) return " + ret); } catch (LastErrorException e) { throw new IllegalStateException("sched_setaffinity((" + Integer.SIZE / 8 + ") , &(" + Integer.toHexString(cpuset32.getValue()) + ") ) errorNo=" + e.getErrorCode(), e); } } @Override public int getCpu() { final CLibrary lib = CLibrary.INSTANCE; try { final int ret = lib.sched_getcpu(); if (ret < 0) throw new IllegalStateException("sched_getcpu( ) return " + ret); return ret; } catch (LastErrorException e) { throw new IllegalStateException("sched_getcpu( ) errorNo=" + e.getErrorCode(), e); } catch (UnsatisfiedLinkError ule) { try { final IntByReference cpu = new IntByReference(); final IntByReference node = new IntByReference(); final int ret = lib.syscall(318, cpu, node, null); if (ret != 0) { throw new IllegalStateException("getcpu( ) return " + ret); } return cpu.getValue(); } catch (LastErrorException lee) { throw new IllegalStateException("getcpu( ) errorNo=" + lee.getErrorCode(), lee); } } } @Override public int getProcessId() { return PROCESS_ID; } @Override public int getThreadId() { if (Utilities.ISLINUX) { Integer tid = THREAD_ID.get(); if (tid == null) THREAD_ID.set(tid = CLibrary.INSTANCE.syscall(SYS_gettid, NO_ARGS)); return tid; } return -1; } /** * @author BegemoT */ interface CLibrary extends Library { CLibrary INSTANCE = Native.load(LIBRARY_NAME, CLibrary.class); int sched_setaffinity(final int pid, final int cpusetsize, final PointerType cpuset) throws LastErrorException; int sched_getaffinity(final int pid, final int cpusetsize, final PointerType cpuset) throws LastErrorException; int sched_getcpu() throws LastErrorException; int getcpu(final IntByReference cpu, final IntByReference node, final PointerType tcache) throws LastErrorException; int getpid() throws LastErrorException; int syscall(int number, Object... args) throws LastErrorException; } } SolarisJNAAffinity.java000066400000000000000000000044641435750131000367740ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.LastErrorException; import com.sun.jna.Library; import com.sun.jna.Native; import net.openhft.affinity.IAffinity; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.lang.management.ManagementFactory; import java.util.BitSet; /** * This is essentially the same as the NullAffinity implementation but with concrete * support for getThreadId(). * * @author daniel.shaya */ public enum SolarisJNAAffinity implements IAffinity { INSTANCE; private static final Logger LOGGER = LoggerFactory.getLogger(SolarisJNAAffinity.class); private final ThreadLocal THREAD_ID = new ThreadLocal<>(); @Override public BitSet getAffinity() { return new BitSet(); } @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)); } @Override public int getCpu() { return -1; } @Override public int getProcessId() { final String name = ManagementFactory.getRuntimeMXBean().getName(); return Integer.parseInt(name.split("@")[0]); } @Override public int getThreadId() { Integer tid = THREAD_ID.get(); if (tid == null) { tid = CLibrary.INSTANCE.pthread_self(); //The tid assumed to be an unsigned 24 bit, see net.openhft.lang.Jvm.getMaxPid() tid = tid & 0xFFFFFF; THREAD_ID.set(tid); } return tid; } interface CLibrary extends Library { CLibrary INSTANCE = Native.load("c", CLibrary.class); int pthread_self() throws LastErrorException; } } Utilities.java000066400000000000000000000051651435750131000353070ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 java.io.ByteArrayOutputStream; import java.io.PrintWriter; import java.util.BitSet; /* * Created by andre on 20/06/15. */ public final class Utilities { public static final boolean ISLINUX = "Linux".equals(System.getProperty("os.name")); static final boolean IS64BIT = is64Bit0(); private Utilities() { throw new InstantiationError("Must not instantiate this class"); } /** * Creates a hexademical representation of the bit set * * @param set the bit set to convert * @return the hexademical string representation */ public static String toHexString(final BitSet set) { ByteArrayOutputStream out = new ByteArrayOutputStream(); PrintWriter writer = new PrintWriter(out); final long[] longs = set.toLongArray(); for (long aLong : longs) { writer.write(Long.toHexString(aLong)); } writer.flush(); return new String(out.toByteArray(), java.nio.charset.StandardCharsets.UTF_8); } public static String toBinaryString(BitSet set) { ByteArrayOutputStream out = new ByteArrayOutputStream(); PrintWriter writer = new PrintWriter(out); final long[] longs = set.toLongArray(); for (long aLong : longs) { writer.write(Long.toBinaryString(aLong)); } writer.flush(); return new String(out.toByteArray(), java.nio.charset.StandardCharsets.UTF_8); } public static boolean is64Bit() { return IS64BIT; } private static boolean is64Bit0() { String systemProp; systemProp = System.getProperty("com.ibm.vm.bitmode"); if (systemProp != null) { return "64".equals(systemProp); } systemProp = System.getProperty("sun.arch.data.model"); if (systemProp != null) { return "64".equals(systemProp); } systemProp = System.getProperty("java.vm.version"); return systemProp != null && systemProp.contains("_64"); } } VanillaCpuLayout.java000066400000000000000000000200171435750131000365610ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.CpuLayout; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.slf4j.LoggerFactory; import java.io.*; import java.util.*; import static java.lang.Integer.parseInt; /** * @author peter.lawrey */ public class VanillaCpuLayout implements CpuLayout { public static final int MAX_CPUS_SUPPORTED = 256; @NotNull private final List cpuDetails; private final int sockets; private final int coresPerSocket; private final int threadsPerCore; VanillaCpuLayout(@NotNull List cpuDetails) { this.cpuDetails = cpuDetails; SortedSet sockets = new TreeSet<>(), cores = new TreeSet<>(), threads = new TreeSet<>(); for (CpuInfo cpuDetail : cpuDetails) { sockets.add(cpuDetail.socketId); cores.add((cpuDetail.socketId << 16) + cpuDetail.coreId); threads.add(cpuDetail.threadId); } this.sockets = sockets.size(); this.coresPerSocket = cores.size() / sockets.size(); this.threadsPerCore = threads.size(); if (cpuDetails.size() != sockets() * coresPerSocket() * threadsPerCore()) { StringBuilder error = new StringBuilder(); error.append("cpuDetails.size= ").append(cpuDetails.size()) .append(" != sockets: ").append(sockets()) .append(" * coresPerSocket: ").append(coresPerSocket()) .append(" * threadsPerCore: ").append(threadsPerCore()).append('\n'); for (CpuInfo detail : cpuDetails) { error.append(detail).append('\n'); } LoggerFactory.getLogger(VanillaCpuLayout.class).warn(error.toString()); } } @NotNull public static VanillaCpuLayout fromProperties(String fileName) throws IOException { return fromProperties(openFile(fileName)); } @NotNull public static VanillaCpuLayout fromProperties(InputStream is) throws IOException { Properties prop = new Properties(); prop.load(is); return fromProperties(prop); } @NotNull public static VanillaCpuLayout fromProperties(@NotNull Properties prop) { List cpuDetails = new ArrayList<>(); for (int i = 0; i < MAX_CPUS_SUPPORTED; i++) { String line = prop.getProperty("" + i); if (line == null) break; String[] word = line.trim().split(" *, *"); CpuInfo details = new CpuInfo(parseInt(word[0]), parseInt(word[1]), parseInt(word[2])); cpuDetails.add(details); } return new VanillaCpuLayout(cpuDetails); } @NotNull public static VanillaCpuLayout fromCpuInfo() throws IOException { return fromCpuInfo("/proc/cpuinfo"); } @NotNull public static VanillaCpuLayout fromCpuInfo(String filename) throws IOException { return fromCpuInfo(openFile(filename)); } private static InputStream openFile(String filename) throws FileNotFoundException { try { return new FileInputStream(filename); } catch (FileNotFoundException e) { InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(filename); if (is == null) throw e; return is; } } @NotNull public static VanillaCpuLayout fromCpuInfo(InputStream is) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8")); String line; List cpuDetails = new ArrayList<>(); CpuInfo details = new CpuInfo(); Map threadCount = new LinkedHashMap<>(); while ((line = br.readLine()) != null) { if (line.trim().isEmpty()) { String key = details.socketId + "," + details.coreId; Integer count = threadCount.get(key); if (count == null) threadCount.put(key, count = 1); else threadCount.put(key, count += 1); details.threadId = count - 1; cpuDetails.add(details); details = new CpuInfo(); details.coreId = cpuDetails.size(); continue; } String[] words = line.split("\\s*:\\s*", 2); if (words[0].equals("physical id")) details.socketId = parseInt(words[1]); else if (words[0].equals("core id")) details.coreId = parseInt(words[1]); } return new VanillaCpuLayout(cpuDetails); } @Override public int cpus() { return cpuDetails.size(); } public int sockets() { return sockets; } public int coresPerSocket() { return coresPerSocket; } @Override public int threadsPerCore() { return threadsPerCore; } @Override public int socketId(int cpuId) { return cpuDetails.get(cpuId).socketId; } @Override public int coreId(int cpuId) { return cpuDetails.get(cpuId).coreId; } @Override public int threadId(int cpuId) { return cpuDetails.get(cpuId).threadId; } @NotNull @Override public String toString() { StringBuilder sb = new StringBuilder(); for (int i = 0, cpuDetailsSize = cpuDetails.size(); i < cpuDetailsSize; i++) { CpuInfo cpuDetail = cpuDetails.get(i); sb.append(i).append(": ").append(cpuDetail).append('\n'); } return sb.toString(); } @Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; VanillaCpuLayout that = (VanillaCpuLayout) o; if (coresPerSocket != that.coresPerSocket) return false; if (sockets != that.sockets) return false; if (threadsPerCore != that.threadsPerCore) return false; return cpuDetails.equals(that.cpuDetails); } @Override public int hashCode() { int result = cpuDetails.hashCode(); result = 31 * result + sockets; result = 31 * result + coresPerSocket; result = 31 * result + threadsPerCore; return result; } static class CpuInfo { int socketId, coreId, threadId; CpuInfo() { } CpuInfo(int socketId, int coreId, int threadId) { this.socketId = socketId; this.coreId = coreId; this.threadId = threadId; } @NotNull @Override public String toString() { return "CpuInfo{" + "socketId=" + socketId + ", coreId=" + coreId + ", threadId=" + threadId + '}'; } @Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; CpuInfo cpuInfo = (CpuInfo) o; if (coreId != cpuInfo.coreId) return false; if (socketId != cpuInfo.socketId) return false; return threadId == cpuInfo.threadId; } @Override public int hashCode() { int result = socketId; result = 31 * result + coreId; result = 31 * result + threadId; return result; } } } VersionHelper.java000066400000000000000000000046701435750131000361210ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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; public class VersionHelper { private static final String DELIM = "."; private final int major; private final int minor; private final int release; public VersionHelper(int major_, int minor_, int release_) { major = major_; minor = minor_; release = release_; } public VersionHelper(String ver) { if (ver != null && (ver = ver.trim()).length() > 0) { final String[] parts = ver.split("\\."); major = parts.length > 0 ? Integer.parseInt(parts[0]) : 0; minor = parts.length > 1 ? Integer.parseInt(parts[1]) : 0; release = parts.length > 2 ? Integer.parseInt(parts[2]) : 0; } else { major = minor = release = 0; } } public String toString() { return major + DELIM + minor + DELIM + release; } public boolean equals(Object o) { if (o != null && (o instanceof VersionHelper)) { VersionHelper ver = (VersionHelper) o; return this.major == ver.major && this.minor == ver.minor && this.release == ver.release; } else { return false; } } public int hashCode() { return (major << 16) | (minor << 8) | release; } @SuppressWarnings({"UnusedDeclaration"}) public boolean majorMinorEquals(final VersionHelper ver) { return ver != null && this.major == ver.major && this.minor == ver.minor; } public boolean isSameOrNewer(final VersionHelper ver) { return ver != null && (this.major > ver.major || this.major == ver.major && (this.minor > ver.minor || this.minor == ver.minor && this.release >= ver.release)); } } WindowsJNAAffinity.java000066400000000000000000000126251435750131000370100ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 com.sun.jna.*; import com.sun.jna.platform.win32.Kernel32; import com.sun.jna.platform.win32.WinDef; import com.sun.jna.platform.win32.WinNT; import com.sun.jna.ptr.LongByReference; import net.openhft.affinity.IAffinity; import org.jetbrains.annotations.Nullable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.BitSet; /** * Implementation of {@link net.openhft.affinity.IAffinity} based on JNA call of * sched_SetThreadAffinityMask/GetProcessAffinityMask from Windows 'kernel32' library. Applicable for * most windows platforms *

* * * @author andre.monteiro */ public enum WindowsJNAAffinity implements IAffinity { INSTANCE; public static final boolean LOADED; private static final Logger LOGGER = LoggerFactory.getLogger(WindowsJNAAffinity.class); private static final ThreadLocal currentAffinity = new ThreadLocal<>(); static { boolean loaded = false; try { INSTANCE.getAffinity(); loaded = true; } catch (UnsatisfiedLinkError e) { LOGGER.warn("Unable to load jna library", e); } LOADED = loaded; } private final ThreadLocal THREAD_ID = new ThreadLocal<>(); @Override public BitSet getAffinity() { BitSet bitSet = currentAffinity.get(); if (bitSet != null) return bitSet; BitSet longs = getAffinity0(); return longs != null ? longs : new BitSet(); } @Override public void setAffinity(final BitSet affinity) { final CLibrary lib = CLibrary.INSTANCE; WinDef.DWORD aff; long[] longs = affinity.toLongArray(); switch (longs.length) { case 0: aff = new WinDef.DWORD(0); break; case 1: aff = new WinDef.DWORD(longs[0]); break; default: throw new IllegalArgumentException("Windows API does not support more than 64 CPUs for thread affinity"); } int pid = getTid(); try { lib.SetThreadAffinityMask(handle(pid), aff); } catch (LastErrorException e) { throw new IllegalStateException("SetThreadAffinityMask((" + pid + ") , &(" + affinity + ") ) errorNo=" + e.getErrorCode(), e); } BitSet affinity2 = getAffinity0(); if (!affinity2.equals(affinity)) { LoggerFactory.getLogger(WindowsJNAAffinity.class).warn("Tried to set affinity to " + affinity + " but was " + affinity2 + " you may have in sufficient access rights"); } currentAffinity.set((BitSet) affinity.clone()); } @Nullable private BitSet getAffinity0() { final CLibrary lib = CLibrary.INSTANCE; final LongByReference cpuset1 = new LongByReference(0); final LongByReference cpuset2 = new LongByReference(0); try { final int ret = lib.GetProcessAffinityMask(handle(-1), cpuset1, cpuset2); // Successful result is positive, according to the docs // https://msdn.microsoft.com/en-us/library/windows/desktop/ms683213%28v=vs.85%29.aspx if (ret <= 0) { throw new IllegalStateException("GetProcessAffinityMask(( -1 ), &(" + cpuset1 + "), &(" + cpuset2 + ") ) return " + ret); } long[] longs = new long[1]; longs[0] = cpuset1.getValue(); return BitSet.valueOf(longs); } catch (Exception e) { LOGGER.error(e.getMessage(), e); } return null; } private WinNT.HANDLE handle(int pid) { return new WinNT.HANDLE(new Pointer(pid)); } public int getTid() { final CLibrary lib = CLibrary.INSTANCE; try { return lib.GetCurrentThread(); } catch (LastErrorException e) { throw new IllegalStateException("GetCurrentThread( ) errorNo=" + e.getErrorCode(), e); } } @Override public int getCpu() { return -1; } @Override public int getProcessId() { return Kernel32.INSTANCE.GetCurrentProcessId(); } @Override public int getThreadId() { Integer tid = THREAD_ID.get(); if (tid == null) THREAD_ID.set(tid = Kernel32.INSTANCE.GetCurrentThreadId()); return tid; } /** * @author BegemoT */ private interface CLibrary extends Library { CLibrary INSTANCE = Native.load("kernel32", CLibrary.class); int GetProcessAffinityMask(final WinNT.HANDLE pid, final PointerType lpProcessAffinityMask, final PointerType lpSystemAffinityMask) throws LastErrorException; void SetThreadAffinityMask(final WinNT.HANDLE pid, final WinDef.DWORD lpProcessAffinityMask) throws LastErrorException; int GetCurrentThread() throws LastErrorException; } } lockchecker/000077500000000000000000000000001435750131000337765ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinityFileLockBasedLockChecker.java000066400000000000000000000232201435750131000413650ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/lockchecker/* * Copyright 2016-2022 chronicle.software * * https://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.lockchecker; import org.jetbrains.annotations.NotNull; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.FileLock; import java.nio.channels.OverlappingFileLockException; import java.nio.file.NoSuchFileException; import java.nio.file.OpenOption; import java.nio.file.attribute.FileAttribute; import java.nio.file.attribute.PosixFilePermission; import java.nio.file.attribute.PosixFilePermissions; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; import java.util.HashSet; import java.util.Set; import static java.nio.file.StandardOpenOption.*; import static net.openhft.affinity.impl.VanillaCpuLayout.MAX_CPUS_SUPPORTED; public class FileLockBasedLockChecker implements LockChecker { private static final int MAX_LOCK_RETRIES = 5; private static final ThreadLocal dfTL = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy.MM" + ".dd 'at' HH:mm:ss z")); private static final FileAttribute> LOCK_FILE_ATTRIBUTES = PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rw-rw-rw-")); private static final Set LOCK_FILE_OPEN_OPTIONS = new HashSet<>(Arrays.asList(READ, WRITE, CREATE, SYNC)); private static final Logger LOGGER = LoggerFactory.getLogger(FileLockBasedLockChecker.class); private static final FileLockBasedLockChecker instance = new FileLockBasedLockChecker(); private final LockReference[] locks = new LockReference[MAX_CPUS_SUPPORTED]; protected FileLockBasedLockChecker() { //nothing } public static LockChecker getInstance() { return instance; } @Override public synchronized boolean isLockFree(int id) { // check if this process already has the lock if (locks[id] != null) { return false; } // check if another process has the lock File lockFile = toFile(id); try (final FileChannel channel = FileChannel.open(lockFile.toPath(), READ)) { // if we can acquire a shared lock, nobody has an exclusive lock 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); } return true; } else { // another process has an exclusive lock return false; } } catch (OverlappingFileLockException e) { // someone else (in the same JVM) has an exclusive lock /* * This shouldn't happen under normal circumstances, we have the singleton * {@link #locks} array to prevent overlapping locks from the same JVM, but * it can occur when there are multiple classloaders in the JVM */ return false; } } catch (NoSuchFileException e) { // no lock file exists, nobody has the lock return true; } catch (IOException e) { LOGGER.warn("An unexpected error occurred checking if the lock was free, assuming it's not", e); return false; } } @Override public synchronized boolean obtainLock(int id, 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; } return false; } catch (ConcurrentLockFileDeletionException e) { attempt++; } } LOGGER.warn("Exceeded maximum retries for locking CPU " + id + ", failing acquire"); return false; } /** * Attempts to acquire an exclusive lock on the core lock file. *

* It will fail if another process already has an exclusive lock on the file. * * @param id The CPU ID to acquire * @param metaInfo The meta-info to write to the file upon successful acquisition * @return The {@link LockReference} if the lock was successfully acquired, null otherwise * @throws IOException If an IOException occurs creating or writing to the file * @throws ConcurrentLockFileDeletionException If another process deleted the file between us opening it and locking it */ private LockReference tryAcquireLockOnFile(int id, String metaInfo) throws IOException, ConcurrentLockFileDeletionException { final File lockFile = toFile(id); final FileChannel fileChannel = FileChannel.open(lockFile.toPath(), LOCK_FILE_OPEN_OPTIONS, LOCK_FILE_ATTRIBUTES); // NOSONAR try { final FileLock fileLock = fileChannel.tryLock(0, Long.MAX_VALUE, false); if (fileLock == null) { // someone else has a lock (exclusive or shared), fail to acquire closeQuietly(fileChannel); return null; } else { if (!lockFile.exists()) { // someone deleted the file between us opening it and acquiring the lock, signal to retry closeQuietly(fileLock, fileChannel); throw new ConcurrentLockFileDeletionException(); } else { // we have the lock, the file exists. That's success. writeMetaInfoToFile(fileChannel, metaInfo); return new LockReference(fileChannel, fileLock); } } } catch (OverlappingFileLockException e) { // someone else (in the same JVM) has a lock, fail to acquire /* * This shouldn't happen under normal circumstances, we have the singleton * {@link #locks} array to prevent overlapping locks from the same JVM, but * it can occur when there are multiple classloaders in the JVM */ closeQuietly(fileChannel); return null; } } private void writeMetaInfoToFile(FileChannel fc, String metaInfo) throws IOException { byte[] content = String.format("%s%n%s", metaInfo, dfTL.get().format(new Date())).getBytes(); ByteBuffer buffer = ByteBuffer.wrap(content); while (buffer.hasRemaining()) { fc.write(buffer); } } @Override 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); } closeQuietly(locks[id].lock, locks[id].channel); locks[id] = null; return true; } return false; } private void closeQuietly(AutoCloseable... closeables) { for (AutoCloseable closeable : closeables) { try { if (closeable != null) { closeable.close(); } } catch (Exception e) { LOGGER.warn("Error closing " + closeable.getClass().getName(), e); } } } @Override public String getMetaInfo(int id) throws IOException { final File file = toFile(id); LockReference lr = locks[id]; if (lr != null) { return readMetaInfoFromLockFileChannel(file, lr.channel); } else { try (FileChannel fc = FileChannel.open(file.toPath(), READ)) { return readMetaInfoFromLockFileChannel(file, fc); } catch (NoSuchFileException e) { return null; } } } private String readMetaInfoFromLockFileChannel(File lockFile, FileChannel lockFileChannel) throws IOException { ByteBuffer buffer = ByteBuffer.allocate(64); int len = lockFileChannel.read(buffer, 0); String content = len < 1 ? "" : new String(buffer.array(), 0, len); if (content.isEmpty()) { LOGGER.warn("Empty lock file {}", lockFile.getAbsolutePath()); return null; } return content.substring(0, content.indexOf("\n")); } @NotNull protected File toFile(int id) { assert id >= 0; return new File(tmpDir(), "cpu-" + id + ".lock"); } private File tmpDir() { final File tempDir = new File(System.getProperty("java.io.tmpdir")); if (!tempDir.exists()) tempDir.mkdirs(); return tempDir; } /** * Thrown when another process deleted the lock file between us opening the file and acquiring the lock */ class ConcurrentLockFileDeletionException extends Exception { } } LockChecker.java000066400000000000000000000017641435750131000370260ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/lockchecker/* * Copyright 2016-2022 chronicle.software * * https://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.lockchecker; import java.io.IOException; /** * @author Tom Shercliff */ public interface LockChecker { boolean isLockFree(int id); boolean obtainLock(int id, String metaInfo) throws IOException; boolean releaseLock(int id); String getMetaInfo(int id) throws IOException; } LockReference.java000066400000000000000000000022041435750131000373460ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/lockchecker/* * Copyright 2016-2022 chronicle.software * * https://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.lockchecker; import java.nio.channels.FileChannel; import java.nio.channels.FileLock; /** * @author Tom Shercliff */ public class LockReference { protected final FileChannel channel; protected final FileLock lock; public LockReference(final FileChannel channel, final FileLock lock) { this.channel = channel; this.lock = lock; } public FileChannel getChannel() { return channel; } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/main/000077500000000000000000000000001435750131000325245ustar00rootroot00000000000000AffinityTestMain.java000066400000000000000000000042271435750131000365330ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/affinity/main/* * Copyright 2016-2022 chronicle.software * * https://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.main; import net.openhft.affinity.Affinity; import net.openhft.affinity.AffinityLock; import java.text.SimpleDateFormat; import java.util.Date; /** * @author Tom Shercliff */ public class AffinityTestMain { public static void main(String[] args) { int cpus = 1; if (args.length == 0) { cpus = AffinityLock.cpuLayout().cpus() / 12; } else { cpus = Integer.valueOf(args[0]); } for (int i = 0; i < cpus; i++) { acquireAndDoWork(); } } private static void acquireAndDoWork() { Thread t = new Thread(() -> { final SimpleDateFormat df = new SimpleDateFormat("yyyy.MM" + ".dd 'at' HH:mm:ss z"); try (AffinityLock al = Affinity.acquireLock()) { String threadName = Thread.currentThread().getName(); 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()); try { Thread.sleep(10000L); } catch (InterruptedException e) { //nothing } } } }); t.start(); } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/000077500000000000000000000000001435750131000312505ustar00rootroot00000000000000ITicker.java000066400000000000000000000014731435750131000333730ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/* * Copyright 2016-2020 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.ticker; /* * Created by Peter Lawrey on 13/07/15. */ public interface ITicker { long nanoTime(); long ticks(); long toNanos(long ticks); double toMicros(double ticks); } Ticker.java000066400000000000000000000031001435750131000332470ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/* * Copyright 2016-2020 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.ticker; import net.openhft.ticker.impl.JNIClock; import net.openhft.ticker.impl.SystemClock; /** * Static factory for available {@link ITicker} interface implementation * * @author Peter.Lawrey */ public final class Ticker { public static final ITicker INSTANCE; static { if (JNIClock.LOADED) { INSTANCE = JNIClock.INSTANCE; } else { INSTANCE = SystemClock.INSTANCE; } } private Ticker() { throw new InstantiationError("Must not instantiate this class"); } /** * @return The current value of the system timer, in nanoseconds. */ public static long ticks() { return INSTANCE.ticks(); } public static long nanoTime() { return toNanos(ticks()); } public static long toNanos(long ticks) { return INSTANCE.toNanos(ticks); } public static double toMicros(long ticks) { return INSTANCE.toMicros(ticks); } }Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/impl/000077500000000000000000000000001435750131000322115ustar00rootroot00000000000000JNIClock.java000066400000000000000000000060441435750131000343750ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/impl/* * Copyright 2016-2020 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.ticker.impl; import net.openhft.ticker.ITicker; import software.chronicle.enterprise.internals.impl.NativeAffinity; import java.util.logging.Logger; /** * JNI-based implementation, trying to use rdtsc() system call * to access the most precise timer available * * @author cheremin * @since 29.12.11, 18:56 */ public enum JNIClock implements ITicker { INSTANCE; public static final boolean LOADED; private static final Logger LOGGER = Logger.getLogger(JNIClock.class.getName()); private static final int FACTOR_BITS = 17; private static final long START; private static long RDTSC_FACTOR = 1 << FACTOR_BITS; private static double RDTSC_MICRO_FACTOR = 1e-3; private static long CPU_FREQUENCY = 1000; static { boolean loaded; long start; try { // ensure it is loaded. NativeAffinity.INSTANCE.getCpu(); estimateFrequency(50); estimateFrequency(200); LOGGER.info("Estimated clock frequency was " + CPU_FREQUENCY + " MHz"); start = rdtsc0(); loaded = true; } catch (UnsatisfiedLinkError ule) { LOGGER.fine("Unable to find libCEInternals in [" + System.getProperty("java.library.path") + "] " + ule); start = 0; loaded = false; } LOADED = loaded; START = start; } static long tscToNano(final long tsc) { return (tsc * RDTSC_FACTOR) >> FACTOR_BITS; } private static void estimateFrequency(int factor) { final long start = System.nanoTime(); long now; while ((now = System.nanoTime()) == start) { } long end = start + factor * 1000000; final long start0 = rdtsc0(); while ((now = System.nanoTime()) < end) { } long end0 = rdtsc0(); end = now; RDTSC_FACTOR = ((end - start) << FACTOR_BITS) / (end0 - start0) - 1; RDTSC_MICRO_FACTOR = 1e-3 * (end - start) / (end0 - start0); CPU_FREQUENCY = (end0 - start0 + 1) * 1000 / (end - start); } native static long rdtsc0(); public long nanoTime() { return tscToNano(rdtsc0() - START); } @Override public long ticks() { return rdtsc0(); } @Override public long toNanos(long ticks) { return tscToNano(ticks); } @Override public double toMicros(double ticks) { return ticks * RDTSC_MICRO_FACTOR; } }SystemClock.java000066400000000000000000000022551435750131000352410ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/net/openhft/ticker/impl/* * Copyright 2016-2020 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.ticker.impl; import net.openhft.ticker.ITicker; /** * Default implementation, use plain {@link System#nanoTime()} * * @author cheremin * @since 29.12.11, 18:54 */ public enum SystemClock implements ITicker { INSTANCE; @Override public long nanoTime() { return System.nanoTime(); } @Override public long ticks() { return nanoTime(); } @Override public long toNanos(long ticks) { return ticks; } @Override public double toMicros(double ticks) { return ticks / 1e3; } }Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/000077500000000000000000000000001435750131000273705ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/chronicle/000077500000000000000000000000001435750131000313365ustar00rootroot00000000000000enterprise/000077500000000000000000000000001435750131000334375ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/chronicleinternals/000077500000000000000000000000001435750131000354365ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/chronicle/enterpriseimpl/000077500000000000000000000000001435750131000363775ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/chronicle/enterprise/internalsNativeAffinity.java000066400000000000000000000037001435750131000421620ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/main/java/software/chronicle/enterprise/internals/impl/* * Copyright 2016-2020 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 software.chronicle.enterprise.internals.impl; import net.openhft.affinity.IAffinity; import java.util.BitSet; public enum NativeAffinity implements IAffinity { INSTANCE; public static final boolean LOADED; static { LOADED = loadAffinityNativeLibrary(); } private native static byte[] getAffinity0(); private native static void setAffinity0(byte[] affinity); private native static int getCpu0(); private native static int getProcessId0(); private native static int getThreadId0(); private native static long rdtsc0(); private static boolean loadAffinityNativeLibrary() { try { System.loadLibrary("CEInternals"); return true; } catch (UnsatisfiedLinkError e) { return false; } } @Override public BitSet getAffinity() { final byte[] buff = getAffinity0(); if (buff == null) { return null; } return BitSet.valueOf(buff); } @Override public void setAffinity(BitSet affinity) { setAffinity0(affinity.toByteArray()); } @Override public int getCpu() { return getCpu0(); } @Override public int getProcessId() { return getProcessId0(); } @Override public int getThreadId() { return getThreadId0(); } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/000077500000000000000000000000001435750131000246505ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/000077500000000000000000000000001435750131000255715ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/000077500000000000000000000000001435750131000263575ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/000077500000000000000000000000001435750131000300225ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/000077500000000000000000000000001435750131000316335ustar00rootroot00000000000000AffinityLockBindMain.java000066400000000000000000000050261435750131000364060ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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 static net.openhft.affinity.AffinityStrategies.*; /** * @author peter.lawrey */ public final class AffinityLockBindMain { private AffinityLockBindMain() { throw new InstantiationError("Must not instantiate this class"); } public static void main(String... args) throws InterruptedException { AffinityLock al = AffinityLock.acquireLock(); try { // find a cpu on a different socket, otherwise a different core. AffinityLock readerLock = al.acquireLock(DIFFERENT_SOCKET, DIFFERENT_CORE); new Thread(new SleepRunnable(readerLock, false), "reader").start(); // find a cpu on the same core, or the same socket, or any free cpu. AffinityLock writerLock = readerLock.acquireLock(SAME_CORE, SAME_SOCKET, ANY); new Thread(new SleepRunnable(writerLock, false), "writer").start(); Thread.sleep(200); } finally { al.release(); } // allocate a whole core to the engine so it doesn't have to compete for resources. al = AffinityLock.acquireCore(false); new Thread(new SleepRunnable(al, true), "engine").start(); Thread.sleep(200); System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks()); } static class SleepRunnable implements Runnable { private final AffinityLock affinityLock; private final boolean wholeCore; SleepRunnable(AffinityLock affinityLock, boolean wholeCore) { this.affinityLock = affinityLock; this.wholeCore = wholeCore; } public void run() { affinityLock.bind(wholeCore); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { affinityLock.release(); } } } } AffinityLockMain.java000066400000000000000000000033301435750131000356050ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * @author peter.lawrey */ public final class AffinityLockMain { private AffinityLockMain() { throw new InstantiationError("Must not instantiate this class"); } public static void main(String... args) throws InterruptedException { AffinityLock al = AffinityLock.acquireLock(); try { new Thread(new SleepRunnable(), "reader").start(); new Thread(new SleepRunnable(), "writer").start(); Thread.sleep(200); } finally { al.release(); } new Thread(new SleepRunnable(), "engine").start(); Thread.sleep(200); System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks()); } private static class SleepRunnable implements Runnable { public void run() { AffinityLock al = AffinityLock.acquireLock(); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { al.release(); } } } } AffinityLockTest.java000066400000000000000000000273751435750131000356570ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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.Utilities; import net.openhft.affinity.impl.VanillaCpuLayout; import net.openhft.affinity.testimpl.TestFileLockBasedLockChecker; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; import static net.openhft.affinity.AffinityLock.PROCESSORS; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.*; import static org.junit.Assume.assumeTrue; /** * @author peter.lawrey */ 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 { 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), }; locks[2].assignedThread = new Thread(new InterrupedThread(), "logger"); locks[2].assignedThread.start(); locks[3].assignedThread = new Thread(new InterrupedThread(), "engine"); locks[3].assignedThread.start(); locks[6].assignedThread = new Thread(new InterrupedThread(), "main"); locks[7].assignedThread = new Thread(new InterrupedThread(), "tcp"); locks[7].assignedThread.start(); final String actual = LockInventory.dumpLocks(locks); assertEquals("0: General use CPU\n" + "1: CPU not available\n" + "2: Thread[logger,5,main] alive=true\n" + "3: Thread[engine,5,main] alive=true\n" + "4: General use CPU\n" + "5: CPU not available\n" + "6: Thread[main,5,main] alive=false\n" + "7: Thread[tcp,5,main] alive=true\n", actual); System.out.println(actual); locks[2].assignedThread.interrupt(); locks[3].assignedThread.interrupt(); locks[6].assignedThread.interrupt(); locks[7].assignedThread.interrupt(); } @Test 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), }; locks[1].assignedThread = new Thread(new InterrupedThread(), "engine"); locks[1].assignedThread.start(); locks[3].assignedThread = new Thread(new InterrupedThread(), "main"); final String actual = LockInventory.dumpLocks(locks); assertEquals("0: General use CPU\n" + "1: Thread[engine,5,main] alive=true\n" + "2: General use CPU\n" + "3: Thread[main,5,main] alive=false\n", actual); System.out.println(actual); locks[1].assignedThread.interrupt(); } @Test 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), }; locks[1].assignedThread = new Thread(new InterrupedThread(), "engine"); locks[1].assignedThread.start(); final String actual = LockInventory.dumpLocks(locks); assertEquals("0: General use CPU\n" + "1: Thread[engine,5,main] alive=true\n", actual); System.out.println(actual); locks[1].assignedThread.interrupt(); } @Test public void assignReleaseThread() throws IOException { if (AffinityLock.RESERVED_AFFINITY.isEmpty()) { System.out.println("Cannot run affinity test as no threads gave been reserved."); System.out.println("Use isolcpus= in grub.conf or use -D" + AffinityLock.AFFINITY_RESERVED + "={hex mask}"); return; } else if (!new File("/proc/cpuinfo").exists()) { System.out.println("Cannot run affinity test as this system doesn't have a /proc/cpuinfo file"); return; } AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo()); assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity()); AffinityLock al = AffinityLock.acquireLock(); assertEquals(1, Affinity.getAffinity().cardinality()); al.release(); assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity()); assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity()); AffinityLock al2 = AffinityLock.acquireCore(); assertEquals(1, Affinity.getAffinity().cardinality()); al2.release(); assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity()); } @Test public void resetAffinity() { assumeTrue(System.getProperty("os.name").contains("nux")); assertTrue(Affinity.getAffinity().cardinality() > 1); try (AffinityLock lock = AffinityLock.acquireLock()) { assertEquals(1, Affinity.getAffinity().cardinality()); assertTrue(lock.resetAffinity()); lock.resetAffinity(false); } assertEquals(1, Affinity.getAffinity().cardinality()); try (AffinityLock lock = AffinityLock.acquireLock()) { } assertTrue(Affinity.getAffinity().cardinality() > 1); } @Test public void testIssue21() throws IOException { if (!new File("/proc/cpuinfo").exists()) { System.out.println("Cannot run affinity test as this system doesn't have a /proc/cpuinfo file"); return; } AffinityLock.cpuLayout(VanillaCpuLayout.fromCpuInfo()); AffinityLock al = AffinityLock.acquireLock(); AffinityLock alForAnotherThread = al.acquireLock(AffinityStrategies.ANY); if (Runtime.getRuntime().availableProcessors() > 2) { AffinityLock alForAnotherThread2 = al.acquireLock(AffinityStrategies.ANY); assertNotSame(alForAnotherThread, alForAnotherThread2); if (alForAnotherThread.cpuId() != -1) assertNotSame(alForAnotherThread.cpuId(), alForAnotherThread2.cpuId()); alForAnotherThread2.release(); } else { assertNotSame(alForAnotherThread, al); if (alForAnotherThread.cpuId() != -1) assertNotSame(alForAnotherThread.cpuId(), al.cpuId()); } alForAnotherThread.release(); al.release(); } @Test public void testIssue19() { System.out.println("AffinityLock.PROCESSORS=" + PROCESSORS); AffinityLock al = AffinityLock.acquireLock(); List locks = new ArrayList<>(); locks.add(al); for (int i = 0; i < 256; i++) locks.add(al = al.acquireLock(AffinityStrategies.DIFFERENT_SOCKET, AffinityStrategies.DIFFERENT_CORE, AffinityStrategies.SAME_SOCKET, AffinityStrategies.ANY)); for (AffinityLock lock : locks) { lock.release(); } } @Test public void testGettid() { System.out.println("cpu= " + Affinity.getCpu()); } @Test public void testAffinity() throws InterruptedException { // System.out.println("Started"); logger.info("Started"); displayStatus(); 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(); } }); t.start(); t.join(); System.out.println("Thread-0 unlocked"); displayStatus(); } System.out.println("All unlocked"); displayStatus(); } @Test public void shouldReturnLockForSpecifiedCpu() { assumeTrue(Runtime.getRuntime().availableProcessors() > 3); try (final AffinityLock affinityLock = AffinityLock.acquireLock(3)) { assertThat(affinityLock.cpuId(), is(3)); } assertEquals(AffinityLock.BASE_AFFINITY, Affinity.getAffinity()); } @Test public void lockFilesShouldBeRemovedOnRelease() { if (!Utilities.ISLINUX) { return; } final AffinityLock lock = AffinityLock.acquireLock(); assertTrue(Files.exists(Paths.get(lockChecker.doToFile(lock.cpuId()).getAbsolutePath()))); lock.release(); assertFalse(Files.exists(Paths.get(lockChecker.doToFile(lock.cpuId()).getAbsolutePath()))); } private void displayStatus() { System.out.println(Thread.currentThread() + " on " + Affinity.getCpu() + "\n" + AffinityLock.dumpLocks()); } @Test public void testAffinityLockDescriptions() { if (!Utilities.ISLINUX) { return; } try (AffinityLock lock = AffinityLock.acquireLock("last")) { assertEquals(PROCESSORS - 1, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("last")) { assertEquals(PROCESSORS - 1, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("last-1")) { assertEquals(PROCESSORS - 2, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("1")) { assertEquals(1, Affinity.getCpu()); } try (AffinityLock lock = AffinityLock.acquireLock("any")) { assertTrue(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock("none")) { assertFalse(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock((String) null)) { assertFalse(lock.bound); } try (AffinityLock lock = AffinityLock.acquireLock("0")) { assertFalse(lock.bound); } } @Test public void testTooHighCpuId() { try (AffinityLock ignored = AffinityLock.acquireLock(123456)) { } } @Test public void testTooHighCpuId2() { try (AffinityLock ignored = AffinityLock.acquireLock(new int[] {123456})) { } } } AffinitySupportMain.java000066400000000000000000000032131435750131000363710ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * @author peter.lawrey */ public final class AffinitySupportMain { private AffinitySupportMain() { throw new InstantiationError("Must not instantiate this class"); } public static void main(String... args) { AffinityLock al = AffinityLock.acquireLock(); try { new Thread(new SleepRunnable(), "reader").start(); new Thread(new SleepRunnable(), "writer").start(); new Thread(new SleepRunnable(), "engine").start(); } finally { al.release(); } System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks()); } private static class SleepRunnable implements Runnable { public void run() { AffinityLock al = AffinityLock.acquireLock(); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { al.release(); } } } } AffinityThreadFactoryMain.java000066400000000000000000000033561435750131000374640ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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 java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import static net.openhft.affinity.AffinityStrategies.*; /** * @author peter.lawrey */ public final class AffinityThreadFactoryMain { private static final ExecutorService ES = Executors.newFixedThreadPool(4, new AffinityThreadFactory("bg", SAME_CORE, DIFFERENT_SOCKET, ANY)); private AffinityThreadFactoryMain() { throw new InstantiationError("Must not instantiate this class"); } public static void main(String... args) throws InterruptedException { for (int i = 0; i < 12; i++) ES.submit(new Callable() { @Override public Void call() throws InterruptedException { Thread.sleep(100); return null; } }); Thread.sleep(200); System.out.println("\nThe assignment of CPUs is\n" + AffinityLock.dumpLocks()); ES.shutdown(); ES.awaitTermination(1, TimeUnit.SECONDS); } } BaseAffinityTest.java000066400000000000000000000026121435750131000356240ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2022 chronicle.software * * https://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 org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.rules.TemporaryFolder; public class BaseAffinityTest { @Rule public TemporaryFolder folder = new TemporaryFolder(); private String originalTmpDir; @Before public void setTmpDirectory() { originalTmpDir = System.getProperty("java.io.tmpdir"); System.setProperty("java.io.tmpdir", folder.getRoot().getAbsolutePath()); } @After public void restoreTmpDirectoryAndReleaseAllLocks() { // don't leave any locks locked for (int i = 0; i < AffinityLock.PROCESSORS; i++) { LockCheck.releaseLock(i); } System.setProperty("java.io.tmpdir", originalTmpDir); } } BootClassPathTest.java000066400000000000000000000020611435750131000357640ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2022 chronicle.software * * https://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 org.junit.Test; import static org.junit.Assert.assertTrue; 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")); } }FileLockLockCheckTest.java000066400000000000000000000041131435750131000365150ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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.testimpl.TestFileLockBasedLockChecker; import org.junit.Assert; import org.junit.Assume; import org.junit.Before; import org.junit.Test; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import static net.openhft.affinity.LockCheck.IS_LINUX; /** * @author Tom Shercliff */ public class FileLockLockCheckTest extends BaseAffinityTest { private final TestFileLockBasedLockChecker lockChecker = new TestFileLockBasedLockChecker(); private int cpu = 5; @Before public void before() { Assume.assumeTrue(IS_LINUX); } @Test public void test() throws IOException { Assert.assertTrue(LockCheck.isCpuFree(cpu)); LockCheck.updateCpu(cpu); Assert.assertEquals(LockCheck.getPID(), LockCheck.getProcessForCpu(cpu)); } @Test public void testPidOnLinux() { Assert.assertTrue(LockCheck.isProcessRunning(LockCheck.getPID())); } @Test public void testReplace() throws IOException { cpu++; Assert.assertTrue(LockCheck.isCpuFree(cpu + 1)); LockCheck.replacePid(cpu, 123L); Assert.assertEquals(123L, LockCheck.getProcessForCpu(cpu)); } @Test public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception { LockCheck.updateCpu(cpu); final File file = lockChecker.doToFile(cpu); new RandomAccessFile(file, "rw").setLength(0); LockCheck.isCpuFree(cpu); } }InterrupedThread.java000066400000000000000000000016231435750131000356720ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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; /** * @author peter.lawrey */ class InterrupedThread implements Runnable { public void run() { try { Thread.sleep(Integer.MAX_VALUE); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } LockCheckTest.java000066400000000000000000000046671435750131000351220ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2020 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.testimpl.TestFileLockBasedLockChecker; import org.junit.Assert; import org.junit.Assume; import org.junit.Before; import org.junit.Test; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.RandomAccessFile; import static net.openhft.affinity.LockCheck.IS_LINUX; /** * @author Rob Austin. */ public class LockCheckTest extends BaseAffinityTest { private final TestFileLockBasedLockChecker lockChecker = new TestFileLockBasedLockChecker(); private int cpu = 11; @Before public void before() { Assume.assumeTrue(IS_LINUX); } @Test public void test() throws IOException { Assert.assertTrue(LockCheck.isCpuFree(cpu)); LockCheck.updateCpu(cpu); Assert.assertEquals(LockCheck.getPID(), LockCheck.getProcessForCpu(cpu)); } @Test public void testPidOnLinux() { Assert.assertTrue(LockCheck.isProcessRunning(LockCheck.getPID())); } @Test public void testReplace() throws IOException { cpu++; Assert.assertTrue(LockCheck.isCpuFree(cpu + 1)); LockCheck.replacePid(cpu, 123L); Assert.assertEquals(123L, LockCheck.getProcessForCpu(cpu)); } @Test public void shouldNotBlowUpIfPidFileIsEmpty() throws Exception { LockCheck.updateCpu(cpu); final File file = lockChecker.doToFile(cpu); new RandomAccessFile(file, "rw").setLength(0); LockCheck.isCpuFree(cpu); } @Test public void shouldNotBlowUpIfPidFileIsCorrupt() throws Exception { LockCheck.updateCpu(cpu); final File file = lockChecker.doToFile(cpu); try (final FileWriter writer = new FileWriter(file, false)) { writer.append("not a number\nnot a date"); } LockCheck.isCpuFree(cpu); } }MultiProcessAffinityTest.java000066400000000000000000000276071435750131000374160ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/* * Copyright 2016-2022 chronicle.software * * https://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.testimpl.TestFileLockBasedLockChecker; import net.openhft.chronicle.testframework.process.ProcessRunner; import org.jetbrains.annotations.NotNull; import org.junit.Assume; import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.charset.StandardCharsets; import java.nio.file.FileAlreadyExistsException; import java.nio.file.StandardOpenOption; import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; import java.util.stream.Collectors; import java.util.stream.IntStream; import static java.lang.String.format; import static net.openhft.affinity.LockCheck.IS_LINUX; import static org.junit.Assert.*; public class MultiProcessAffinityTest extends BaseAffinityTest { private static final Logger LOGGER = LoggerFactory.getLogger(MultiProcessAffinityTest.class); @Before public void setUp() { Assume.assumeTrue(IS_LINUX); } @Test public void shouldNotAcquireLockOnCoresLockedByOtherProcesses() throws IOException, InterruptedException { // run the separate affinity locker final Process affinityLockerProcess = ProcessRunner.runClass(AffinityLockerProcess.class, new String[]{"-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath()}, new String[]{"last"}); try { int lastCpuId = AffinityLock.PROCESSORS - 1; // wait for the CPU to be locked long endTime = System.currentTimeMillis() + 5_000; while (LockCheck.isCpuFree(lastCpuId)) { Thread.sleep(100); if (System.currentTimeMillis() > endTime) { LOGGER.info("Timed out waiting for the lock to be acquired: isAlive={}, exitCode={}", affinityLockerProcess.isAlive(), affinityLockerProcess.isAlive() ? "N/A" : affinityLockerProcess.exitValue()); ProcessRunner.printProcessOutput("AffinityLockerProcess", affinityLockerProcess); fail("Timed out waiting for the sub-process to acquire the lock"); } } try (AffinityLock lock = AffinityLock.acquireLock("last")) { assertNotEquals(lastCpuId, lock.cpuId()); } } finally { affinityLockerProcess.destroy(); waitForProcessToEnd(5, "Affinity locker process", affinityLockerProcess, false); } } @Test public void shouldAllocateCoresCorrectlyUnderContention() throws IOException, InterruptedException { final int numberOfLockers = Math.max(2, Math.min(12, Runtime.getRuntime().availableProcessors())) / 2; List lockers = new ArrayList<>(); LOGGER.info("Running test with {} locker processes", numberOfLockers); for (int i = 0; i < numberOfLockers; i++) { lockers.add(ProcessRunner.runClass(RepeatedAffinityLocker.class, new String[]{"-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath()}, new String[]{"last", "30", "2"})); } for (int i = 0; i < numberOfLockers; i++) { final Process process = lockers.get(i); waitForProcessToEnd(20, "Locking process", process); } } @Test public void shouldAllocateCoresCorrectlyUnderContentionWithFailures() throws IOException, InterruptedException { final int numberOfLockers = Math.max(2, Math.min(12, Runtime.getRuntime().availableProcessors())) / 2; List lockers = new ArrayList<>(); LOGGER.info("Running test with {} locker processes", numberOfLockers); Process lockFileDropper = ProcessRunner.runClass(LockFileDropper.class); for (int i = 0; i < numberOfLockers; i++) { lockers.add(ProcessRunner.runClass(RepeatedAffinityLocker.class, new String[]{"-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath()}, new String[]{"last", "30", "2"})); } for (int i = 0; i < numberOfLockers; i++) { final Process process = lockers.get(i); waitForProcessToEnd(20, "Locking process", process); } lockFileDropper.destroy(); waitForProcessToEnd(5, "Lock file droppper", lockFileDropper); } @Test public void shouldBeAbleToAcquireLockLeftByOtherProcess() throws IOException, InterruptedException { final Process process = ProcessRunner.runClass(AffinityLockerThatDoesNotReleaseProcess.class, new String[]{"-Djava.io.tmpdir=" + folder.getRoot().getAbsolutePath()}, new String[]{"last"}); waitForProcessToEnd(5, "Locking process", process); // We should be able to acquire the lock despite the other process not explicitly releasing it try (final AffinityLock acquired = AffinityLock.acquireLock("last")) { assertEquals(AffinityLock.PROCESSORS - 1, acquired.cpuId()); } } private void waitForProcessToEnd(int timeToWaitSeconds, String processDescription, Process process) throws InterruptedException { waitForProcessToEnd(timeToWaitSeconds, processDescription, process, true); } private void waitForProcessToEnd(int timeToWaitSeconds, String processDescription, Process process, boolean checkExitCode) throws InterruptedException { if (!process.waitFor(timeToWaitSeconds, TimeUnit.SECONDS)) { ProcessRunner.printProcessOutput(processDescription, process); fail(processDescription + " didn't end in time"); } if (checkExitCode && process.exitValue() != 0) { ProcessRunner.printProcessOutput(processDescription, process); fail(processDescription + " failed, see output above (exit value " + process.exitValue() + ")"); } } /** * Repeatedly acquires and releases a lock on the specified core */ static class RepeatedAffinityLocker implements Callable { private static final Logger LOGGER = LoggerFactory.getLogger(RepeatedAffinityLocker.class); private static final long PID = LockCheck.getPID(); private final int iterations; private final String cpuIdToLock; public static void main(String[] args) throws InterruptedException, ExecutionException { String cpuIdToLock = args[0]; int iterations = Integer.parseInt(args[1]); int threads = Integer.parseInt(args[2]); LOGGER.info("Acquiring lock with {} threads, {} iterations", threads, iterations); ExecutorService executorService = Executors.newFixedThreadPool(threads); final List> futures = executorService.invokeAll(IntStream.range(0, threads) .mapToObj(tid -> new RepeatedAffinityLocker(cpuIdToLock, iterations)) .collect(Collectors.toList())); for (Future future : futures) { future.get(); } executorService.shutdown(); if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) { throw new IllegalStateException("Executor service didn't shut down"); } } public RepeatedAffinityLocker(String cpuIdToLock, int iterations) { this.iterations = iterations; this.cpuIdToLock = cpuIdToLock; } @Override public Void call() throws Exception { for (int i = 0; i < iterations; i++) { LOGGER.info("******* Starting iteration {} at {}", i, LocalDateTime.now()); try (final AffinityLock affinityLock = AffinityLock.acquireLock(cpuIdToLock)) { if (affinityLock.isAllocated()) { assertLockFileContainsMyPid(affinityLock); Thread.sleep(ThreadLocalRandom.current().nextInt(50)); assertLockFileContainsMyPid(affinityLock); } else { LOGGER.info("Couldn't get a lock"); } } } return null; } private void assertLockFileContainsMyPid(AffinityLock affinityLock) throws IOException { int lockPID = LockCheck.getProcessForCpu(affinityLock.cpuId()); if (lockPID != PID) { throw new IllegalStateException(format("PID in lock file is not mine (lockPID=%d, myPID=%d)", lockPID, PID)); } } } /** * Acquires a lock on the specified CPU, holds it until interrupted */ static class AffinityLockerProcess { private static final Logger LOGGER = LoggerFactory.getLogger(AffinityLockerProcess.class); 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()); 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"); } } } /** * Acquires a lock then ends */ static class AffinityLockerThatDoesNotReleaseProcess { private static final Logger LOGGER = LoggerFactory.getLogger(AffinityLockerProcess.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()); } } /** * Simulate failing processes by repeatedly dropping lock files * with PIDs of non-existent processes */ static class LockFileDropper { public static void main(String[] args) throws InterruptedException, IOException { while (Thread.currentThread().isInterrupted()) { for (int cpu = 0; cpu < AffinityLock.PROCESSORS; cpu++) { try { File lockFile = toFile(cpu); try (final FileChannel fc = FileChannel.open(lockFile.toPath(), StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)) { final long maxValue = Long.MAX_VALUE; // a PID that never exists ByteBuffer buffer = ByteBuffer.wrap((maxValue + "\n").getBytes(StandardCharsets.UTF_8)); while (buffer.hasRemaining()) { fc.write(buffer); } } } catch (FileAlreadyExistsException e) { LOGGER.info("Failed, trying again"); } Thread.sleep(ThreadLocalRandom.current().nextInt(50)); } } } @NotNull protected static File toFile(int id) { return new TestFileLockBasedLockChecker().doToFile(id); } } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/000077500000000000000000000000001435750131000325745ustar00rootroot00000000000000AbstractAffinityImplTest.java000066400000000000000000000054101435750131000402770ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.IAffinity; import org.junit.After; import org.junit.Test; import java.util.BitSet; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; /** * @author cheremin * @since 29.12.11, 20:25 */ public abstract class AbstractAffinityImplTest { protected static final int CORES = Runtime.getRuntime().availableProcessors(); protected static final BitSet CORES_MASK = new BitSet(CORES); static { CORES_MASK.set(0, CORES, true); } public abstract IAffinity getImpl(); @Test public void getAffinityCompletesGracefully() { getImpl().getAffinity(); } @Test public void getAffinityReturnsValidValue() { final BitSet affinity = getImpl().getAffinity(); assertTrue( "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 + ")", affinity.length() <= CORES_MASK.length() ); } @Test public void setAffinityCompletesGracefully() { BitSet affinity = new BitSet(1); affinity.set(0, true); getImpl().setAffinity(affinity); } @Test public void getAffinityReturnsValuePreviouslySet() { final IAffinity impl = getImpl(); for (int core = 0; core < CORES; core++) { final BitSet mask = new BitSet(); mask.set(core, true); getAffinityReturnsValuePreviouslySet(impl, mask); } } private void getAffinityReturnsValuePreviouslySet(final IAffinity impl, final BitSet mask) { impl.setAffinity(mask); final BitSet _mask = impl.getAffinity(); assertEquals(mask, _mask); } @After public void tearDown() { try { getImpl().setAffinity(CORES_MASK); } catch (Exception e) { e.printStackTrace(); } } } LinuxJNAAffinityTest.java000066400000000000000000000031731435750131000373460ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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.Assume; import org.junit.BeforeClass; import org.junit.Test; import java.util.BitSet; import static org.junit.Assert.assertEquals; /* * Created by Peter Lawrey on 23/03/16. */ public class LinuxJNAAffinityTest { @BeforeClass public static void checkJniLibraryPresent() { Assume.assumeTrue(LinuxJNAAffinity.LOADED); } @Test public void LinuxJNA() { int nbits = Runtime.getRuntime().availableProcessors(); BitSet affinity0 = LinuxJNAAffinity.INSTANCE.getAffinity(); System.out.println(affinity0); BitSet affinity = new BitSet(nbits); affinity.set(1); LinuxJNAAffinity.INSTANCE.setAffinity(affinity); BitSet affinity2 = LinuxJNAAffinity.INSTANCE.getAffinity(); System.out.println(affinity2); assertEquals(1, LinuxJNAAffinity.INSTANCE.getCpu()); assertEquals(affinity, affinity2); affinity.set(0, nbits); LinuxJNAAffinity.INSTANCE.setAffinity(affinity); } } NativeAffinityImpTest.java000066400000000000000000000040171435750131000376100ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.Affinity; import net.openhft.affinity.IAffinity; import org.junit.Assume; import org.junit.BeforeClass; import org.junit.Test; import software.chronicle.enterprise.internals.impl.NativeAffinity; import static org.junit.Assert.assertTrue; /* * Created by andre on 22/06/15. */ public class NativeAffinityImpTest extends AbstractAffinityImplTest { @BeforeClass public static void checkJniLibraryPresent() { Assume.assumeTrue(NativeAffinity.LOADED); Assume.assumeTrue("linux".equalsIgnoreCase(System.getProperty("os.name"))); } @Override public IAffinity getImpl() { return NativeAffinity.INSTANCE; } @Test public void testGettid() { System.out.println("pid=" + getImpl().getProcessId()); System.out.println("tid=" + getImpl().getThreadId()); Affinity.setThreadId(); for (int j = 0; j < 3; j++) { final int runs = 100000; long tid = 0; long time = 0; for (int i = 0; i < runs; i++) { long start = System.nanoTime(); tid = Thread.currentThread().getId(); time += System.nanoTime() - start; assertTrue(tid > 0); assertTrue(tid < 1 << 16); } System.out.printf("gettid took an average of %,d ns, tid=%d%n", time / runs, tid); } } } PosixJNAAffinityTest.java000066400000000000000000000036231435750131000373510ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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 net.openhft.affinity.Affinity; import net.openhft.affinity.IAffinity; import org.junit.Assume; import org.junit.BeforeClass; import org.junit.Test; import static org.junit.Assert.assertTrue; /** * @author peter.lawrey */ public class PosixJNAAffinityTest extends AbstractAffinityImplTest { @BeforeClass public static void checkJniLibraryPresent() { Assume.assumeTrue("linux".equalsIgnoreCase(System.getProperty("os.name"))); } @Override public IAffinity getImpl() { return Affinity.getAffinityImpl(); } @Test public void testGettid() { System.out.println("pid=" + getImpl().getProcessId()); System.out.println("tid=" + getImpl().getThreadId()); Affinity.setThreadId(); for (int j = 0; j < 3; j++) { final int runs = 100000; long tid = 0; long time = 0; for (int i = 0; i < runs; i++) { long start = System.nanoTime(); tid = Thread.currentThread().getId(); time += System.nanoTime() - start; assertTrue(tid > 0); assertTrue(tid < 1 << 24); } System.out.printf("gettid took an average of %,d ns, tid=%d%n", time / runs, tid); } } } VanillaCpuLayoutTest.java000066400000000000000000000146121435750131000374600ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 2016-2020 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; /** * @author peter.lawrey */ public class VanillaCpuLayoutTest { @Test public void testFromCpuInfoI7() 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()); } @Test public void testFromCpuInfoOthers() throws IOException { { final InputStream is = getClass().getClassLoader().getResourceAsStream("amd64.dual.core.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); assertEquals("0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" + "1: CpuInfo{socketId=0, coreId=1, threadId=0}\n", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("core.duo.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); assertEquals("0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" + "1: CpuInfo{socketId=0, coreId=1, threadId=0}\n", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("amd64.quad.core.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); 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", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("dual.xeon.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); assertEquals("0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" + "1: CpuInfo{socketId=0, coreId=0, threadId=1}\n" + "2: CpuInfo{socketId=3, coreId=3, threadId=0}\n" + "3: CpuInfo{socketId=3, coreId=3, threadId=1}\n", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("i3.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); assertEquals("0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" + "1: CpuInfo{socketId=0, coreId=2, threadId=0}\n" + "2: CpuInfo{socketId=0, coreId=0, threadId=1}\n" + "3: CpuInfo{socketId=0, coreId=2, threadId=1}\n", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("q6600.noht.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); assertEquals("0: CpuInfo{socketId=0, coreId=0, threadId=0}\n" + "1: CpuInfo{socketId=0, coreId=2, threadId=0}\n" + "2: CpuInfo{socketId=0, coreId=1, threadId=0}\n" + "3: CpuInfo{socketId=0, coreId=3, threadId=0}\n", vcl.toString()); } { final InputStream is = getClass().getClassLoader().getResourceAsStream("dual.E5405.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(is); 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=1, coreId=4, threadId=0}\n" + "5: CpuInfo{socketId=1, coreId=5, threadId=0}\n" + "6: CpuInfo{socketId=1, coreId=6, threadId=0}\n" + "7: CpuInfo{socketId=1, coreId=7, threadId=0}\n", vcl.toString()); } } @Test public void testNoIDs() throws IOException { final InputStream noids = getClass().getClassLoader().getResourceAsStream("q6600.vm.cpuinfo"); VanillaCpuLayout vcl = VanillaCpuLayout.fromCpuInfo(noids); 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", vcl.toString()); } @Test public void testFromProperties() throws IOException { final InputStream i7 = getClass().getClassLoader().getResourceAsStream("i7.properties"); VanillaCpuLayout vcl = VanillaCpuLayout.fromProperties(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()); } } VersionHelperTest.java000066400000000000000000000027541435750131000370150ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/impl/* * Copyright 20127chronicle.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.Assert; import org.junit.Test; public class VersionHelperTest { @Test public void isSameOrNewerTest() { final VersionHelper v0 = new VersionHelper(0, 0, 0); final VersionHelper v2_6 = new VersionHelper(2, 6, 0); final VersionHelper v4_1 = new VersionHelper(4, 1, 1); final VersionHelper v4_9 = new VersionHelper(4, 9, 0); final VersionHelper v9_9 = new VersionHelper(9, 9, 9); VersionHelper[] versions = new VersionHelper[]{v0, v2_6, v4_1, v4_9, v9_9}; for (int i = 0; i < versions.length; i++) { for (int j = 0; j < versions.length; j++) { Assert.assertEquals(String.format("expected %s.isSameOrNewer(%s) to be %b", versions[i], versions[j], i >= j), i >= j, versions[i].isSameOrNewer(versions[j])); } } } } testimpl/000077500000000000000000000000001435750131000334155ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinityTestFileLockBasedLockChecker.java000066400000000000000000000016401435750131000416460ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/affinity/testimpl/* * Copyright 2016-2022 chronicle.software * * https://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.testimpl; import net.openhft.affinity.lockchecker.FileLockBasedLockChecker; import java.io.File; public class TestFileLockBasedLockChecker extends FileLockBasedLockChecker { public File doToFile(int cpu) { return toFile(cpu); } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/ticker/000077500000000000000000000000001435750131000313035ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/ticker/impl/000077500000000000000000000000001435750131000322445ustar00rootroot00000000000000JNIClockTest.java000066400000000000000000000051451435750131000352710ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/net/openhft/ticker/impl/* * Copyright 2016-2020 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.ticker.impl; import net.openhft.affinity.Affinity; import org.junit.Ignore; import org.junit.Test; import static org.junit.Assert.assertEquals; /* * Created by Peter Lawrey on 13/07/15. */ public class JNIClockTest { @Test @Ignore("TODO Fix") public void testNanoTime() throws InterruptedException { for (int i = 0; i < 20000; i++) System.nanoTime(); Affinity.setAffinity(2); JNIClock instance = JNIClock.INSTANCE; for (int i = 0; i < 50; i++) { long start0 = System.nanoTime(); long start1 = instance.ticks(); Thread.sleep(10); long time0 = System.nanoTime(); long time1 = instance.ticks(); if (i > 1) { assertEquals(10_100_000, time0 - start0, 100_000); assertEquals(10_100_000, instance.toNanos(time1 - start1), 100_000); assertEquals(instance.toNanos(time1 - start1) / 1e3, instance.toMicros(time1 - start1), 0.6); } } } @Test @Ignore("Long running") public void testJitter() { Affinity.setAffinity(2); assertEquals(2, Affinity.getCpu()); int samples = 100000, count = 0; long[] time = new long[samples]; long[] length = new long[samples]; JNIClock clock = JNIClock.INSTANCE; long start = clock.ticks(), prev = start, prevJump = start; for (int i = 0; i < 1000_000_000; i++) { long now = clock.ticks(); long delta = now - prev; if (delta > 4_000) { time[count] = now - prevJump; prevJump = now; length[count] = delta; count++; if (count >= samples) break; } prev = now; } for (int i = 0; i < count; i++) { System.out.println(((long) (clock.toMicros(time[i]) * 10)) / 10.0 + ", " + ((long) (clock.toMicros(length[i]) * 10) / 10.0)); } } }Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/000077500000000000000000000000001435750131000274235ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/chronicle/000077500000000000000000000000001435750131000313715ustar00rootroot00000000000000enterprise/000077500000000000000000000000001435750131000334725ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/chronicleinternals/000077500000000000000000000000001435750131000354715ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/chronicle/enterpriseJnaAffinityTest.java000066400000000000000000000070251435750131000414020ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/chronicle/enterprise/internals/* * Copyright 2016-2020 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 software.chronicle.enterprise.internals; import net.openhft.affinity.IAffinity; import net.openhft.affinity.impl.LinuxJNAAffinity; import net.openhft.affinity.impl.Utilities; import org.junit.After; import org.junit.Assume; import org.junit.BeforeClass; import org.junit.Test; import java.util.BitSet; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; /** * @author peter.lawrey */ public class JnaAffinityTest { protected static final int CORES = Runtime.getRuntime().availableProcessors(); protected static final BitSet CORES_MASK = new BitSet(CORES); static { CORES_MASK.set(0, CORES, true); } @BeforeClass public static void checkJniLibraryPresent() { Assume.assumeTrue(LinuxJNAAffinity.LOADED); } @Test public void getAffinityCompletesGracefully() { System.out.println("affinity: " + Utilities.toBinaryString(getImpl().getAffinity())); } @Test public void getAffinityReturnsValidValue() { final BitSet affinity = getImpl().getAffinity(); assertTrue( "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 + ")", affinity.length() <= CORES_MASK.length() ); } @Test public void setAffinityCompletesGracefully() { BitSet affinity = new BitSet(1); affinity.set(0, true); getImpl().setAffinity(affinity); } @Test public void getAffinityReturnsValuePreviouslySet() { String osName = System.getProperty("os.name"); if (!osName.startsWith("Linux")) { System.out.println("Skipping Linux tests"); return; } final IAffinity impl = LinuxJNAAffinity.INSTANCE; final int cores = CORES; for (int core = 0; core < cores; core++) { final BitSet mask = new BitSet(); mask.set(core, true); getAffinityReturnsValuePreviouslySet(impl, mask); } } @Test public void showOtherIds() { System.out.println("processId: " + LinuxJNAAffinity.INSTANCE.getProcessId()); System.out.println("threadId: " + LinuxJNAAffinity.INSTANCE.getThreadId()); System.out.println("cpu: " + LinuxJNAAffinity.INSTANCE.getCpu()); } private void getAffinityReturnsValuePreviouslySet(final IAffinity impl, final BitSet mask) { impl.setAffinity(mask); final BitSet _mask = impl.getAffinity(); assertEquals(mask, _mask); } @After public void tearDown() { getImpl().setAffinity(CORES_MASK); } public IAffinity getImpl() { return LinuxJNAAffinity.INSTANCE; } } NativeAffinityTest.java000066400000000000000000000107761435750131000421270ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/java/software/chronicle/enterprise/internals/* * Copyright 2016-2020 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 software.chronicle.enterprise.internals; import net.openhft.affinity.IAffinity; import net.openhft.affinity.impl.LinuxJNAAffinity; import net.openhft.affinity.impl.Utilities; import org.junit.*; import software.chronicle.enterprise.internals.impl.NativeAffinity; import java.util.BitSet; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; /** * @author peter.lawrey */ public class NativeAffinityTest { protected static final int CORES = Runtime.getRuntime().availableProcessors(); protected static final BitSet CORES_MASK = new BitSet(CORES); static { CORES_MASK.set(0, CORES, true); } @BeforeClass public static void checkJniLibraryPresent() { Assume.assumeTrue(NativeAffinity.LOADED); } @Test public void getAffinityCompletesGracefully() { System.out.println("affinity: " + Utilities.toBinaryString(getImpl().getAffinity())); } @Test public void getAffinityReturnsValidValue() { final BitSet affinity = getImpl().getAffinity(); assertTrue( "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 + ")", affinity.length() <= CORES_MASK.length() ); } @Test public void setAffinityCompletesGracefully() { BitSet affinity = new BitSet(1); affinity.set(0, true); getImpl().setAffinity(affinity); } @Test @Ignore("TODO AFFINITY-25") public void getAffinityReturnsValuePreviouslySet() { String osName = System.getProperty("os.name"); if (!osName.startsWith("Linux")) { System.out.println("Skipping Linux tests"); return; } final IAffinity impl = NativeAffinity.INSTANCE; final int cores = CORES; for (int core = 0; core < cores; core++) { final BitSet mask = new BitSet(); mask.set(core, true); getAffinityReturnsValuePreviouslySet(impl, mask); } } @Test @Ignore("TODO AFFINITY-25") public void JNAwithJNI() { String osName = System.getProperty("os.name"); if (!osName.startsWith("Linux")) { System.out.println("Skipping Linux tests"); return; } int nbits = Runtime.getRuntime().availableProcessors(); BitSet affinity = new BitSet(nbits); affinity.set(1); NativeAffinity.INSTANCE.setAffinity(affinity); BitSet affinity2 = LinuxJNAAffinity.INSTANCE.getAffinity(); assertEquals(1, NativeAffinity.INSTANCE.getCpu()); assertEquals(affinity, affinity2); affinity.clear(); affinity.set(2); LinuxJNAAffinity.INSTANCE.setAffinity(affinity); BitSet affinity3 = NativeAffinity.INSTANCE.getAffinity(); assertEquals(2, LinuxJNAAffinity.INSTANCE.getCpu()); assertEquals(affinity, affinity3); affinity.set(0, nbits); LinuxJNAAffinity.INSTANCE.setAffinity(affinity); } @Test public void showOtherIds() { System.out.println("processId: " + NativeAffinity.INSTANCE.getProcessId()); System.out.println("threadId: " + NativeAffinity.INSTANCE.getThreadId()); System.out.println("cpu: " + NativeAffinity.INSTANCE.getCpu()); } private void getAffinityReturnsValuePreviouslySet(final IAffinity impl, final BitSet mask) { impl.setAffinity(mask); final BitSet _mask = impl.getAffinity(); assertEquals(mask, _mask); } @After public void tearDown() { getImpl().setAffinity(CORES_MASK); } public IAffinity getImpl() { return NativeAffinity.INSTANCE; } } Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/000077500000000000000000000000001435750131000266625ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/amd64.dual.core.cpuinfo000066400000000000000000000031641435750131000330410ustar00rootroot00000000000000processor : 0 vendor_id : AuthenticAMD cpu family : 15 model : 107 model name : Athlon 64 Dual Core 5000+ stepping : 2 cpu MHz : 2599.998 cache size : 512 KB physical id : 0 siblings : 2 core id : 0 cpu cores : 2 fpu : yes fpu_exception : yes cpuid level : 1 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow rep_good pni cx16 lahf_lm cmp_legacy svm extapic cr8_legacy 3dnowprefetch bogomips : 5204.18 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: ts fid vid ttp tm stc 100mhzsteps processor : 1 vendor_id : AuthenticAMD cpu family : 15 model : 107 model name : Athlon 64 Dual Core 5000+ stepping : 2 cpu MHz : 2599.998 cache size : 512 KB physical id : 0 siblings : 2 core id : 1 cpu cores : 2 fpu : yes fpu_exception : yes cpuid level : 1 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow rep_good pni cx16 lahf_lm cmp_legacy svm extapic cr8_legacy 3dnowprefetch bogomips : 5200.04 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: ts fid vid ttp tm stc 100mhzsteps Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/amd64.quad.core.cpuinfo000066400000000000000000000064641435750131000330540ustar00rootroot00000000000000processor : 0 vendor_id : AuthenticAMD cpu family : 16 model : 4 model name : Quad-Core AMD Opteron(tm) Processor 2374 HE stepping : 2 cpu MHz : 2194.255 cache size : 512 KB physical id : 0 siblings : 4 core id : 0 cpu cores : 4 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm 3dnowext 3dnow constant_tsc rep_good nonstop_tsc extd_apicid pni monitor cx16 popcnt lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt bogomips : 4388.50 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 48 bits physical, 48 bits virtual power management: ts ttp tm stc 100mhzsteps hwpstate processor : 1 vendor_id : AuthenticAMD cpu family : 16 model : 4 model name : Quad-Core AMD Opteron(tm) Processor 2374 HE stepping : 2 cpu MHz : 2194.255 cache size : 512 KB physical id : 0 siblings : 4 core id : 1 cpu cores : 4 apicid : 1 initial apicid : 1 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm 3dnowext 3dnow constant_tsc rep_good nonstop_tsc extd_apicid pni monitor cx16 popcnt lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt bogomips : 4389.05 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 48 bits physical, 48 bits virtual power management: ts ttp tm stc 100mhzsteps hwpstate processor : 2 vendor_id : AuthenticAMD cpu family : 16 model : 4 model name : Quad-Core AMD Opteron(tm) Processor 2374 HE stepping : 2 cpu MHz : 2194.255 cache size : 512 KB physical id : 0 siblings : 4 core id : 2 cpu cores : 4 apicid : 2 initial apicid : 2 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm 3dnowext 3dnow constant_tsc rep_good nonstop_tsc extd_apicid pni monitor cx16 popcnt lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt bogomips : 4389.05 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 48 bits physical, 48 bits virtual power management: ts ttp tm stc 100mhzsteps hwpstate processor : 3 vendor_id : AuthenticAMD cpu family : 16 model : 4 model name : Quad-Core AMD Opteron(tm) Processor 2374 HE stepping : 2 cpu MHz : 2194.255 cache size : 512 KB physical id : 0 siblings : 4 core id : 3 cpu cores : 4 apicid : 3 initial apicid : 3 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm 3dnowext 3dnow constant_tsc rep_good nonstop_tsc extd_apicid pni monitor cx16 popcnt lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt bogomips : 4389.05 TLB size : 1024 4K pages clflush size : 64 cache_alignment : 64 address sizes : 48 bits physical, 48 bits virtual power management: ts ttp tm stc 100mhzsteps hwpstate Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/core.duo.cpuinfo000066400000000000000000000026101435750131000317640ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 23 model name : Intel(R) Core(TM)2 Duo CPU T8300 @ 2.40GHz stepping : 6 cpu MHz : 800.000 cache size : 3072 KB physical id : 0 siblings : 2 core id : 0 cpu cores : 2 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good nopl pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 lahf_lm ida bogomips : 4787.93 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 23 model name : Intel(R) Core(TM)2 Duo CPU T8300 @ 2.40GHz stepping : 6 cpu MHz : 800.000 cache size : 3072 KB physical id : 0 siblings : 2 core id : 1 cpu cores : 2 apicid : 1 initial apicid : 1 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good nopl pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 lahf_lm ida bogomips : 4787.96 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/dual.E5405.cpuinfo000066400000000000000000000125001435750131000316730ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 0 siblings : 4 core id : 0 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3992.50 processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 0 siblings : 4 core id : 1 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.03 processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 0 siblings : 4 core id : 2 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.01 processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 0 siblings : 4 core id : 3 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.11 processor : 4 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 1 siblings : 4 core id : 4 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.09 processor : 5 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 1 siblings : 4 core id : 5 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.05 processor : 6 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 1 siblings : 4 core id : 6 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.07 processor : 7 vendor_id : GenuineIntel cpu family : 6 model : 7 model name : Intel(R) Xeon(R) CPU E5405 @ 2.00GHz stepping : 6 cpu MHz : 1995.138 cache size : 6144 KB physical id : 1 siblings : 4 core id : 7 cpu cores : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx lm pni monitor ds_cpl tm2 xtpr bogomips : 3990.02 Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/dual.xeon.cpuinfo000066400000000000000000000044101435750131000321430ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 15 model : 4 model name : Intel(R) Xeon(TM) MP CPU 3.66GHz stepping : 1 cpu MHz : 3670.025 cache size : 1024 KB physical id : 0 siblings : 2 core id : 0 cpu cores : 1 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall lm pni monitor ds_cpl est tm2 cid cx16 xtpr bogomips : 7208.96 clflush size : 64 cache_alignment : 128 address sizes : 40 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 15 model : 4 model name : Intel(R) Xeon(TM) MP CPU 3.66GHz stepping : 1 cpu MHz : 3670.025 cache size : 1024 KB physical id : 0 siblings : 2 core id : 0 cpu cores : 1 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall lm pni monitor ds_cpl est tm2 cid cx16 xtpr bogomips : 7323.64 clflush size : 64 cache_alignment : 128 address sizes : 40 bits physical, 48 bits virtual power management: processor : 2 vendor_id : GenuineIntel cpu family : 15 model : 4 model name : Intel(R) Xeon(TM) MP CPU 3.66GHz stepping : 1 cpu MHz : 3670.025 cache size : 1024 KB physical id : 3 siblings : 2 core id : 3 cpu cores : 1 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall lm pni monitor ds_cpl est tm2 cid cx16 xtpr bogomips : 7323.64 clflush size : 64 cache_alignment : 128 address sizes : 40 bits physical, 48 bits virtual power management: processor : 3 vendor_id : GenuineIntel cpu family : 15 model : 4 model name : Intel(R) Xeon(TM) MP CPU 3.66GHz stepping : 1 cpu MHz : 3670.025 cache size : 1024 KB physical id : 3 siblings : 2 core id : 3 cpu cores : 1 fpu : yes fpu_exception : yes cpuid level : 5 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall lm pni monitor ds_cpl est tm2 cid cx16 xtpr bogomips : 7323.64 clflush size : 64 cache_alignment : 128 address sizes : 40 bits physical, 48 bits virtual power management: Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/i3.cpuinfo000066400000000000000000000064041435750131000305660ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 37 model name : Intel(R) Core(TM) i3 CPU 530 @ 2.93GHz stepping : 2 cpu MHz : 1200.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 0 cpu cores : 2 apicid : 0 initial apicid : 0 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx rdtscp lm constant_tsc arch_perfmon pebs bts xtopology nonstop_tsc aperfmperf pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm sse4_1 sse4_2 popcnt lahf_lm arat tpr_shadow vnmi flexpriority ept vpid bogomips : 5866.15 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 37 model name : Intel(R) Core(TM) i3 CPU 530 @ 2.93GHz stepping : 2 cpu MHz : 1200.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 2 cpu cores : 2 apicid : 4 initial apicid : 4 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx rdtscp lm constant_tsc arch_perfmon pebs bts xtopology nonstop_tsc aperfmperf pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm sse4_1 sse4_2 popcnt lahf_lm arat tpr_shadow vnmi flexpriority ept vpid bogomips : 5866.64 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 37 model name : Intel(R) Core(TM) i3 CPU 530 @ 2.93GHz stepping : 2 cpu MHz : 1200.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 0 cpu cores : 2 apicid : 1 initial apicid : 1 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx rdtscp lm constant_tsc arch_perfmon pebs bts xtopology nonstop_tsc aperfmperf pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm sse4_1 sse4_2 popcnt lahf_lm arat tpr_shadow vnmi flexpriority ept vpid bogomips : 5866.62 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 37 model name : Intel(R) Core(TM) i3 CPU 530 @ 2.93GHz stepping : 2 cpu MHz : 1200.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 2 cpu cores : 2 apicid : 5 initial apicid : 5 fdiv_bug : no hlt_bug : no f00f_bug : no coma_bug : no fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe nx rdtscp lm constant_tsc arch_perfmon pebs bts xtopology nonstop_tsc aperfmperf pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm sse4_1 sse4_2 popcnt lahf_lm arat tpr_shadow vnmi flexpriority ept vpid bogomips : 5866.65 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/i7.cpuinfo000066400000000000000000000126601435750131000305730ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 0 cpu cores : 4 apicid : 0 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.47 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 1 cpu cores : 4 apicid : 2 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.26 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 2 cpu cores : 4 apicid : 4 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.07 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 3 cpu cores : 4 apicid : 6 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.11 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 4 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 0 cpu cores : 4 apicid : 1 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6799.97 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 5 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 1 cpu cores : 4 apicid : 3 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.06 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 6 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 2 cpu cores : 4 apicid : 5 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6800.03 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] processor : 7 vendor_id : GenuineIntel cpu family : 6 model : 42 model name : Intel(R) Core(TM) i7-2600K CPU @ 3.40GHz stepping : 7 cpu MHz : 3400.235 cache size : 8192 KB physical id : 0 siblings : 8 core id : 3 cpu cores : 4 apicid : 7 fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm constant_tsc ida nonstop_tsc arat pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr sse4_1 sse4_2 popcnt lahf_lm bogomips : 6799.88 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: [8] Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/i7.properties000066400000000000000000000012301435750131000313130ustar00rootroot00000000000000# # Copyright 2016 higherfrequencytrading.com # # 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=0,0,1 5=0,1,1 6=0,2,1 7=0,3,1 Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/q6600.noht.cpuinfo000066400000000000000000000055101435750131000317730ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 0 cpu cores : 4 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.72 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 2 cpu cores : 4 apicid : 2 initial apicid : 2 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.82 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 1 cpu cores : 4 apicid : 1 initial apicid : 1 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.81 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB physical id : 0 siblings : 4 core id : 3 cpu cores : 4 apicid : 3 initial apicid : 3 fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.82 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/affinity/src/test/resources/q6600.vm.cpuinfo000066400000000000000000000047651435750131000314600ustar00rootroot00000000000000processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.72 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.82 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.81 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz stepping : 11 cpu MHz : 1596.000 cache size : 4096 KB fpu : yes fpu_exception : yes cpuid level : 10 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good pni dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm lahf_lm tpr_shadow vnmi flexpriority bogomips : 4810.82 clflush size : 64 cache_alignment : 64 address sizes : 36 bits physical, 48 bits virtual power management: Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/docs/000077500000000000000000000000001435750131000222215ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/docs/images/000077500000000000000000000000001435750131000234665ustar00rootroot00000000000000Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/docs/images/Thread-Affinity_line.png000066400000000000000000000433611435750131000301700ustar00rootroot00000000000000PNG  IHDR;T pHYs&? IDATx͕҆{m,‚90‚6-,Emj=qoPVeJL}TPdDFDqcvEuxND_5^ۻ?ToϕwJ2W%ew4DtyQ?>ξwF%78TmT,YqڝT(\iÝ=s?G_G/wr?ʕ:sg;ayBsԻ޿'GϡO6tNjFfu K׎B{Q_j}+oRs@M1&z%U|1#h9y=LjsADhentgaIeb땱1%IT!!ĀٽƖ3(b".38/boRq,&L;́.T`LPs~$EO@'9! B7)'/ÐRs|HS_f >s1'֔T|dvLUG%gg&̰Q́~87Ir5t軱vѽұr!{enp [uL@yFyݨē7rdg3o1(f!t9.Q2w=6* pr#gNei$~V[Լb\gcth*ܩBȼP%.Qo\sxl)fe]$H7M3צ HUkܸ+ <OĘJC0|UN {bf$E#kn>ݠ홮]dzy0꽎:_m٘E.{/o⫍~q /h-MWdu/IM h55>z?v8f{.t& Nm/w;ͿmTnRpZu}2:;B%M?Z)S S{nX# "":ݮo_Wo4\'tު`qѷMA]Gc3u^$PϥQSThTI8OEN^q}V^3{(8? VIR ^scČ ^X$O1;sN <3 6 hF<^q9툥=C^z.*A2uPXKi(z&6%ߠvTpm@;}gu_r{g?MǮGgLcɃ,EI>RnP9?s "KAcԱoP^oPňoP2=Sw`F=$K~T3=@<=ܠ=عOtųo A l`2 E'AҍR%GFupx@uEXQDG{>]sI){ +l\۱7p[ezfhE-evrS&9Ù~/bᡘ\0@zFHփj;t?bH7_!61@zS+L1kPO{wJmM d\_+ŵ-[sÈH>-km4եTH*>7A)댈pj] 'aHkplʙYebu"n8p,M&c<=RIjeHj>ÝbLsy)ҹF>}7iI>C#,5x.GYKQPr 1s-X㡛u=LΜ:ZWhϢk|UG㺇^॔x Uix'(7Z9IbV5HPw}+}NJ1-$KHj0C.@$T$}4\}4$@de -J"ZGW]MmԚ޵؀9"Uz"Ū- N|]#7B@ hk/<џț_[r{ ܞۤ|rv)ˈ?\# juJ#Cjc}vܐ\ .8QACD/R~0mu|8!҅Z+X4'l),BfĂs< Pd$T P C"٬>6V~Pu-y"e7$X<@CPMB4u &I۳ `΀l`)yj D фd7ODRU]_2V%aJjgUiUaL8N>eS-^~:}-eF4鸝}5\իziH^@D/Yv_T?(GMӁpC5i>&eQD,y9RMQcVXXߩP*"!e S ^Tr!Ɏ;A} nRiI +tvѴN2SA 翎Ͼ0|֏&"MErs24^2TQyB)m } d娴#a?a{M,6*Ǿ"Mv*o&fx`Q+#7;<%#@FLKiTjii#B4̹SNJF|ETrA5m2@ƕewP+(-t[Lj DPN5@Bz@'.Bkb@R[|gy @N:!C`{@2jG'Dp=,>8?TJ~8bs(Hx1 DaJXhmØ]  Xh,ip暃Xh "2wqv=A[,FSj?)!2|1iP*\V"'zxkEqhz{9M-%J MVDCuA M8Q]Ó55fwYQmܙ aZ7+6Xb!}he.4jQ &}iٿ}]ȄD57vps*2x-< >D>+9?uAgA&vPVb$S4ᙳHdSzN0KQTU=)W"PcA7Qv"xRdppV@G9 UNg"XG3XSAlb4͗t> HOQO'H: z4ph=K0E |"a sΊ "UC Q`Mg.zɠ]%'#liZTѱx0(xsshoQ|t#׆F~Hސqɦ]<خ5 9Bʢ|!#´J1c^*'5'k!bF<$3>U=Lk-u;$93IR:t+L10upXOVT# K(0 !3@|^ƳvkIєN: OVSe>5VLxv:n7asa?PCrsK˓!-.}ҼL,.^&eWK /:\+IC:!u lr XA}Zw*^aUz!Ra8qGm}LAc4! "< Wz k eܑg.8!O6 / ;"n 5ϩ]mg& E`G*F!:4 aGީE[  X`>{s*QTZHn@X$ ʋ @hjb۞KjǮ!L#@8dƨGNQ^Qk]!n MsOmlҸ;]PZpmEMk%Xs*ȰtSjR-W9[Y8V_⚭JV!@=Ӄy_Iv AZ86R Ңk/R haNgﲐc}oB +s{^їخ.үF  w|" 6ReکNԎ}z5)=tNd7yvϪ~鮕 tޱm45m !s  +0@7ߕ߉d-3&[@QҡRyŢ9L|n8kF:6}ZJFl赊-p滪*ʠo\#Euڑu߆åmg('3mS̍>fέN~98r:6Θx\#Zʭm+@T IDATo^k>>mXLqco$,PʗMHVO댽 EUjaX4%$7)S͉BaymkjM鸽s[jD 97Ÿb>Q;+:AyA]7󃦵Γ녺nS Q? SmN:Vdz A=s>F$KDTMBȉZHQ1©rQ$ĝ_mЃaLq-`v&E/HpF.i_(žDu7&}H<؛ ؓRpj 'E3D._6v3d'3Ӝ:^ 'mGG7dwH"űD- ٦ayJ?mqk>U[GI=)nxv‹}7y2;1mFxMuI)\d&HXidD1}d(OFhc '@KA+7*@5D@ IW+v~a g{ʝ=%@g_FX* ] @qhbiHS¨v yK[i U8tcۡ XF=<`BNxL6# 74JLtUUp-&T;{,-DB)@_a uTCOX~=YG'@g73Lõ"ςQ)RDU9C.DNTN𔪃e'B$HKa((REPK PBec [E 2[ @/\B'p,h ţ@Zw~@pFqy Zc~~@iamI{@(-Ɠ3Ҭ26zRDAG:6(%@ozH 9rN(2[@6jeRqLY^'@ƣ}+&J2 ) MNzxy/h+( Pwtw1:;!CLwQ?o>kt,μͧV{Mm $nxIEz;St6+T#\Y8v5)R}Yunx`*]dT4q( @ј&Id2k9aQ=gI:EwҵMA;Ӂ)\|k9X3\F]٘P:/7c%_ U1C8{g^63pxSzA5.ZxMHT }Ӂ`/H+FHЃX+&{7NΦ djTG>{>Lصa`X>ܟ7& NDbG3s26^8U7~9t:n/qr6C$=a6QuzxB@QK|Q3}:tܪTƦ/@D 4'4iۺ":D"4BL"gt4m{ k:7`7 >}34BVԊcGeh&Jp º(]Č&@Zq컇~Θ }mgxP?.,3@dtJ+!r35C27:PEtxEuPmQT9+gQDp(8S*53!Kqz:7bVPprԒrUR:Jq8T-y}:BԅS_b:Ȑ:#Mwq "Bafx;v[YxKʤ8|FQrANQ~[ڇ(li_UĆ+y;8ET #&A(q,׶S=ȗRm{Ar׶ .\GTږ9vgPElk݌`:DV> .@ʹ(_(&q0,qEyQP'uU~mI#"ڡ</^޴ P72'F ""=ॐUbl_#vs#exq#au7WĄGg3Ϫy:l2oZ<;HfUq:y3Ehts%Ƚ5 Q{GsܳdJ NeĴM-2 Ѥ}][H1k6U=&<$M їFpi9Eҝ$hvi>} 诵98<KOJ{pIDtLv`*}Uvw'/@D(Qfw $ 7T\hsLx *8 6Y":؍bhZGwlq+h8dE P wH2 [IrR ]BfAԖUPpMOCmwbkw$nO|Ay)Z'|(! -K?웘 ߃ JwoDh3r@ %S./cގ68=9~b*@>-[[o҉O6= @ `o)|IP4YSP(RS#i< 1dRxBtk+ץ:W&ij>P Fo{QQuAs׭#N"ZEum]P+ XQTQL5}2 >_V= #zIӞ#2?2!'X9 Z@֗"z+)g_ZE?QyɏR/(Hkf >s<[JWC?PBx Y<{J(,H^ݸ {]f r38DЃh?WډݭAI3krjz@ yx@@<5ZGȯ#[j}X`Fx 0i%\:zl d(;jl#H%dϱP ÞsS04JHHQ.AZwL2x? e@ ރh{`:nxҢRSS{ :(# PB=epHǀ2%DNOMATB+"d>-&&ˆ/dneĬZ 9(<@ %V U0Plp ]bjPQ@^*]Pޅ0]m4ꔐ"qkXGAyXB,?~("za} J+!N}:n_ey Jw؎% Cz,}Pj߼XXPD kN~1ڢuY|,/\F"ᮺO1Z6bQRBFf&jRDQ=1nOciQT/dV,uqbLh71=pC>eazpW26@JBYTy-Y*:\Z? rx.fe7o_bF0/#!J0aaA+g fe *Z xju~ "J pɪ4 ЊNE\o' J:Y,]zQRBꜩq{[T$/Rm!yKo&/@vvk43 q{kEW¯Eu5KZ qk>OaVĊB""`?v r jYrL$N*n+VH" >$9% ƾ@ۚbmj{CɭI)!6l6 72;C!pEYr ŤH&:0glY%@=q3D ;uQ,+s,둄%T}Ԃ6cS z9p:n/9 ]OCo!։A.`atPB[B3l0?T4Z29 ϶ 1rpk^ {cV{sCӊ:K%B:t>3/b/iDAZLrXcOΚ^L DIqNh%Kژ\CrO;cE|;wYknź-9 ѷlJk zBÙ6;֧v3+6>'FB%1"\pЇ6N򴊎&8Nǭ͸x޳o a쳄h SrAh:gw[_k1qAh="QNDe~Oz2i^A+BZǵ ͷ ƛ z_:˖$C{Q6+D[O3e (VYB簄E󮠀 "uqC觮kYTuqJ5Ft gN !74)!|wX@Hjv-~\:$}4,(h RuQPbAPo{{ 91 C(NmST7$ BBhKׁ^/x X.Îdp4SC9n65p5xWBŞ>2^*IӍ`JJcK X<{!KI8h4ڶKHoH.D䨄Bm\vb=Zp%ރw֐%$тFdnkIR-s05dx-HTy\5b RG+8A³AJ|RB\K"TґA `mHb('R42ZX \VQUB"$F#l"4BeyK*V֐2Ȓ+^Ц P~nj3Y8 \H\rD0RBJAӽ@X8u: 'pSKH@ |^Ц4T \q a$ᦱ RFd\lcODJHym'Pkb%Ĺ"j_jr$B-hcT&&`@vR>3QBI#i$LѺ(! @ᜥ@4vWq(8(sRtJ'Jb1QBN11p,bǾM-h#N)!^#=1+b#hSI⺽s1 3`EH\r3JpN)h: ^Jh#lUMx "'ɿsw같t͌ 6 aHX+R%^7T ! ;PskA*x-C%UB]i7 K)hDUAZڙH F!0,Mq 0HT ERa^lVB%)E|63gBLLD܃)D\5MP-i\! ]pg5AF*id|mR @f `iHڤC:,$n0y#hS;l& ڔ}nMRخ6T 4\Q^ @ $KF 42-kNǭ""ݤ_"񏠍U.X6Ԧv$;~QheħԂ-`V [m>K%2 ,!$iJ%ִof+-YB%FT7'A) W! +!楰5XAF"h# n8)U:s#'HE%r良!!ӹO` _RInXy]A M ³AT%^:ڂ)!ZдD̿ 2Bzz2"":/I}+e4<!(7"] \ 1/> bDBnK.}n/}lMq*(!T*k("07c3HQӐutp(v)hڰk沄:!7 *jAlI9*9 KBIn0xa6%D'5HWw\g`4'gs[*!m"EfD:tAZ9 ) ("\s`.jI#M2A;a( ("RDF*S jd==(DSBDƊZAH T7id\#$y5!Qу"FPQE!2D+v|#YPC (  yYTo ڔcCP3)Nm (%DxJ }6 ~80 -EIDAT˂˥q;k(!6t>%W_vͿ@^ l~u:nJRJt>#[a\g,wYYBM<*uM\IR ~/l߱N<j$ J2IEI'""2RDp#+[?>>R鸍$IH+qVU`^)A ®Ru@$~2zޒpDǕyYTv ف#ï^䢀2:XH%jCiSTfݤhj: q(¯%dc u;ZWov K稀2TBcb|E`$$TJ)stH?VPUBDD"i`V 8, W/P84i*wlYcMV ҤW 1xRlC]v_ٟ[v`EpIc7HJ,®!kw $/he p=F=Y"Z% ϋqB+5@o̹3=bIVBD_H^mh7 ƒcCԆ]g&eJ󄾐Ze@`cOVZ,K峪u(ˇhXD]+nXrjVY2R8yt,K7,+vV uX,ZaಸPZRZTF Ü!] EuxGD-I %4RZ4 oO ÂqSRu@`6x"rCfP>& Y|^.`^H)p HYYID P(PBX&v: a8/仦Va%#bA)a+V4k3#$R 侮n[jj}5>wԮ3%0:hObj< N +VZ stO,N9+O&B, (X)uџDt ipul6NKgE@ v߽}sMIEr lNet P:JÂZ)~yM= @ =S;AQࢹϩoߡ-^FR&Ŧ~*QxvOt.#kHCk(!BJɔzN =vwu$Gi,BɃ@ p4UI?Atn  0PB f*xA*@ (7jZx#J;j]fPh`ɀ'~~?sOB/, E-WIENDB`Java-Thread-Affinity-Java-Thread-Affinity-3.23.3/pom.xml000066400000000000000000000033521435750131000226110ustar00rootroot00000000000000 4.0.0 net.openhft root-parent-pom 1.2.21 Java-Thread-Affinity 3.23.3 pom OpenHFT/Java-Thread-Affinity Parent Java Thread Affinity library affinity affinity-test scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git scm:git:git@github.com:OpenHFT/Java-Thread-Affinity.git Java-Thread-Affinity-3.23.3