Merge remote-tracking branch 'origin/master'

peter-lawrey · peter-lawrey · commit 35ba9fac058d · 2017-09-07T23:47:48.000+01:00
diff --git a/README.md b/README.md
@@ -1,40 +1,56 @@
 Thread Affinity
 =============
 
-Lets you bind a thread to a given core, this can improve performance ( this libary works best on linux )
+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 the affinity/src/test/java for working examples of how to use this library.
+See [affinity/src/test/java](https://github.com/OpenHFT/Java-Thread-Affinity/tree/master/affinity/src/test/java) 
+for working examples of how to use this library.
 
 [Thread Affinity usage Heatmap](http://jrvis.com/red-dwarf/?user=openhft&repo=Java-Thread-Affinity)
 
-## Versions
+## Changes
 
-V2.2 - Latest build.
-V2.0.1 - Added getThreadId for the process if of the thread.
+   - 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 [JNA](https://github.com/java-native-access/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 `<version>` 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 JAN on Centos
+    sudo apt-get install libjna-java
+
+
+### Installing JNA on CentOS
+
+    sudo yum install jna
 
-----
-sudo yum install jna
-----
 
-## How does 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 Socket.
+## How CPU does 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-mark-in-hex} to the command line of the process
+To control which CPUs a process can use, add -Daffinity.reserved={cpu-mask-in-hex} to the command line of the process.
 
 Note: the CPU 0 is reserved for the Operating System, it has to run somewhere.
 
@@ -89,7 +105,7 @@ You can get the current thread id using
 
     int threadId = AffinitySupport.getThreadId();
 
-## determining which CPU you are running on.
+## Determining which CPU you are running on.
 You can get the current CPU being used by
 
     int cpuId = AffinitySupport.getCpu();
diff --git a/affinity/src/main/java/net/openhft/affinity/BootClassPath.java b/affinity/src/main/java/net/openhft/affinity/BootClassPath.java
@@ -19,41 +19,97 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import sun.misc.URLClassPath;
 
-import java.io.File;
-import java.net.MalformedURLException;
-import java.net.URL;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+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 URLClassPath bootClassPath = new URLClassPath(getBootClassPathURLs());
+    private final Set<String> bootClassPathResources = Collections.unmodifiableSet(getResourcesOnBootClasspath());
 
     public final boolean has(String binaryClassName) {
-        String resourceClassName = binaryClassName.replace('.', '/').concat(".class");
-        return bootClassPath.getResource(resourceClassName, false) != null;
+        final String resourceClassName = binaryClassName.replace('.', '/').concat(".class");
+        return bootClassPathResources.contains(resourceClassName);
     }
 
-    private URL[] getBootClassPathURLs() {
-        Logger LOGGER = LoggerFactory.getLogger(BootClassPath.class);
-        try {
-            String bootClassPath = System.getProperty("sun.boot.class.path");
-            LOGGER.trace("Boot class-path is: {}", bootClassPath);
+    private static Set<String> getResourcesOnBootClasspath() {
+        final Logger logger = LoggerFactory.getLogger(BootClassPath.class);
+        final Set<String> resources = new HashSet<>();
+        final String bootClassPath = System.getProperty("sun.boot.class.path");
+        logger.trace("Boot class-path is: {}", bootClassPath);
+
+        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<String> findResources(final Path path, final Logger logger) {
+        if (!Files.exists(path)) {
+            return Collections.emptySet();
+        }
+
+        if (Files.isDirectory(path)) {
+            return findResourcesInDirectory(path, logger);
+        }
 
-            String pathSeparator = System.getProperty("path.separator");
-            LOGGER.trace("Path separator is: '{}'", pathSeparator);
+        return findResourcesInJar(path, logger);
+    }
 
-            String[] pathElements = bootClassPath.split(pathSeparator);
-            URL[] pathURLs = new URL[pathElements.length];
-            for (int i = 0; i < pathElements.length; i++) {
-                pathURLs[i] = new File(pathElements[i]).toURI().toURL();
+    private static Set<String> findResourcesInJar(final Path path, final Logger logger) {
+        final Set<String> jarResources = new HashSet<>();
+        try {
+            final JarFile jarFile = new JarFile(path.toFile());
+            final Enumeration<JarEntry> entries = jarFile.entries();
+            while (entries.hasMoreElements()) {
+                final JarEntry jarEntry = entries.nextElement();
+                if (jarEntry.getName().endsWith(".class")) {
+                    jarResources.add(jarEntry.getName());
+                }
             }
 
-            return pathURLs;
-        } catch (MalformedURLException e) {
-            LOGGER.warn("Parsing the boot class-path failed! Reason: {}", e.getMessage());
-            return new URL[0];
+
+        } catch (IOException e) {
+            logger.warn("Not a jar file: {}", path);
+        }
+
+        return jarResources;
+    }
+
+    private static Set<String> findResourcesInDirectory(final Path path, final Logger logger) {
+        final Set<String> dirResources = new HashSet<>();
+        try {
+            Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
+                @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;
     }
 }
diff --git a/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java b/affinity/src/test/java/net/openhft/affinity/BootClassPathTest.java
@@ -0,0 +1,13 @@
+package net.openhft.affinity;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class BootClassPathTest {
+    @Test
+    public void shouldDetectClassesOnClassPath() throws Exception {
+        assertTrue(BootClassPath.INSTANCE.has("java.lang.Thread"));
+        assertTrue(BootClassPath.INSTANCE.has("java.lang.Runtime"));
+    }
+}
