Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*-
* JCuda - Java bindings for NVIDIA CUDA driver and runtime API
*
* Copyright (c) 2009-2015 Marco Hutter - http://www.jcuda.org
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
package org.nd4j.linalg.api.buffer.util;
import org.nd4j.linalg.io.ClassPathResource;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Locale;
/**
* Utility class for detecting the operating system and architecture
* types, and automatically loading the matching native library
* as a resource or from a file.
*
* The architecture and OS detection has been adapted from
* http://javablog.co.uk/2007/05/19/making-jni-cross-platform/
* and extended with http://lopica.sourceforge.net/os.html
*/
public final class LibUtils {
/**
* Enumeration of common operating systems, independent of version
* or architecture.
*/
public enum OSType {
APPLE, LINUX, SUN, WINDOWS, UNKNOWN
}
/**
* Enumeration of common CPU architectures.
*/
public enum ARCHType {
PPC, PPC_64, SPARC, X86, X86_64, ARM, MIPS, RISC, UNKNOWN
}
/**
* Prepend jni to the name for certain classes
* @param clazz
*/
public static void loadJavaCpp(Class clazz) {
loadLibrary("jni" + clazz.getSimpleName());
}
/**
* Loads the specified library. The full name of the library
* is created by calling {@link LibUtils#createLibName(String)}
* with the given argument. The method will attempt to load
* the library as a as a resource (for usage within a JAR),
* and, if this fails, using the usual System.loadLibrary
* call.
*
* @param baseName The base name of the library
* @throws UnsatisfiedLinkError if the native library
* could not be loaded.
*/
public static void loadLibrary(String baseName) {
String libName = LibUtils.createLibName(baseName);
Throwable throwable = null;
try {
loadLibraryResource(libName);
return;
} catch (Throwable t) {
throwable = t;
}
try {
System.loadLibrary(libName);
return;
} catch (Throwable t) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
pw.println("Error while loading native library \"" + libName + "\" with base name \"" + baseName + "\"");
pw.println("Operating system name: " + System.getProperty("os.name"));
pw.println("Architecture : " + System.getProperty("os.arch"));
pw.println("Architecture bit size: " + System.getProperty("sun.arch.data.model"));
if (throwable != null) {
pw.println("Stack trace from the attempt to " + "load the library as a resource:");
throwable.printStackTrace(pw);
}
pw.println("Stack trace from the attempt to " + "load the library as a file:");
t.printStackTrace(pw);
pw.flush();
pw.close();
throw new UnsatisfiedLinkError("Could not load the native library.\n" + sw.toString());
}
}
/**
* Load the library with the given name from a resource.
* The extension for the current OS will be appended.
*
* @param libName The library name
* @throws Throwable If the library could not be loaded
*/
public static void loadTempBinaryFile(String libName) throws Exception {
String libPrefix = createLibPrefix();
String libExtension = createLibExtension();
String fullName = libPrefix + libName;
String resourceName = fullName + "." + libExtension;
ClassPathResource resource = new ClassPathResource(resourceName);
InputStream inputStream = resource.getInputStream();
if (inputStream == null) {
throw new NullPointerException("No resource found with name '" + resourceName + "'");
}
File tempFile = new File(System.getProperty("java.io.tmpdir"), fullName + "." + libExtension);
tempFile.deleteOnExit();
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(tempFile);
byte[] buffer = new byte[8192];
while (true) {
int read = inputStream.read(buffer);
if (read < 0) {
break;
}
outputStream.write(buffer, 0, read);
}
outputStream.flush();
outputStream.close();
outputStream = null;
System.load(tempFile.getAbsolutePath());
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
/**
* Load the library with the given name from a resource.
* The extension for the current OS will be appended.
*
* @param libName The library name
* @throws Throwable If the library could not be loaded
*/
public static void loadTempBinaryFile(Class libName) throws Exception {
String os = getOsName();
String arch = getArchName();
String resourceFolder = os + "-" + arch;
String libPrefix = createLibPrefix();
String libExtension = createLibExtension();
StringBuilder sb = new StringBuilder().append(libName.getPackage().getName().replace(".", "/") + "/")
.append(resourceFolder).append("/").append(libPrefix)
.append("jni" + libName.getSimpleName() + ".").append(libExtension);
String resourceName = sb.toString();
ClassPathResource resource = new ClassPathResource(resourceName);
InputStream inputStream = resource.getInputStream();
if (inputStream == null) {
throw new NullPointerException("No resource found with name '" + resourceName + "'");
}
String fullName = libPrefix + "jni" + libName.getSimpleName() + "." + libExtension;
File tempFile = new File(System.getProperty("java.io.tmpdir"), fullName);
tempFile.deleteOnExit();
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(tempFile);
byte[] buffer = new byte[8192];
while (true) {
int read = inputStream.read(buffer);
if (read < 0) {
break;
}
outputStream.write(buffer, 0, read);
}
outputStream.flush();
outputStream.close();
outputStream = null;
System.load(tempFile.getAbsolutePath());
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
/**
* Load the library with the given name from a resource.
* The extension for the current OS will be appended.
*
* @param libName The library name
* @throws Throwable If the library could not be loaded
*/
public static void loadJavaCppResource(String libName) throws Throwable {
String libPrefix = createLibPrefix();
String libExtension = createLibExtension();
String fullName = libPrefix + libName;
String resourceName = fullName + "." + libExtension;
ClassPathResource resource = new ClassPathResource(resourceName);
InputStream inputStream = resource.getInputStream();
if (inputStream == null) {
throw new NullPointerException("No resource found with name '" + resourceName + "'");
}
File tempFile = File.createTempFile(fullName, "." + libExtension);
tempFile.deleteOnExit();
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(tempFile);
byte[] buffer = new byte[8192];
while (true) {
int read = inputStream.read(buffer);
if (read < 0) {
break;
}
outputStream.write(buffer, 0, read);
}
outputStream.flush();
outputStream.close();
outputStream = null;
System.load(tempFile.toString());
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
/**
* Adds the specified path to the java library path
*
* @param pathToAdd the path to add
* @throws Exception
*/
public static void addLibraryPath(String pathToAdd) throws Exception {
final Field usrPathsField = ClassLoader.class.getDeclaredField("usr_paths");
usrPathsField.setAccessible(true);
//get array of paths
final String[] paths = (String[]) usrPathsField.get(null);
//check if the path to add is already present
for (String path : paths) {
if (path.equals(pathToAdd)) {
return;
}
}
//add the new path
final String[] newPaths = Arrays.copyOf(paths, paths.length + 1);
newPaths[newPaths.length - 1] = pathToAdd;
usrPathsField.set(null, newPaths);
}
/**
* Load the library with the given name from a resource.
* The extension for the current OS will be appended.
*
* @param libName The library name
* @throws Throwable If the library could not be loaded
*/
private static void loadLibraryResource(String libName) throws Throwable {
String libPrefix = createLibPrefix();
String libExtension = createLibExtension();
String fullName = libPrefix + libName;
String resourceName = "/lib/" + fullName + "." + libExtension;
InputStream inputStream = LibUtils.class.getResourceAsStream(resourceName);
if (inputStream == null) {
throw new NullPointerException("No resource found with name '" + resourceName + "'");
}
File tempFile = File.createTempFile(fullName, "." + libExtension);
tempFile.deleteOnExit();
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(tempFile);
byte[] buffer = new byte[8192];
while (true) {
int read = inputStream.read(buffer);
if (read < 0) {
break;
}
outputStream.write(buffer, 0, read);
}
outputStream.flush();
outputStream.close();
outputStream = null;
System.load(tempFile.toString());
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
/**
* Get the name of the os
* for libary discovery on the classpath
* @return
*/
public static String getOsName() {
OSType osType = calculateOS();
switch (osType) {
case APPLE:
return "macosx";
case LINUX:
return "linux";
case SUN:
return "sun";
case WINDOWS:
return "windows";
}
return "";
}
public static String getArchName() {
ARCHType archType = calculateArch();
switch (archType) {
case X86:
return "x86";
case X86_64:
return "x86_64";
case ARM:
return "arm";
case PPC:
return "ppc";
case PPC_64:
return "ppc64";
case RISC:
return "risc";
default:
return "unknown";
}
}
/**
* Returns the extension for dynamically linked libraries on the
* current OS. That is, returns "dylib" on Apple, "so" on Linux
* and Sun, and "dll" on Windows.
*
* @return The library extension
*/
private static String createLibExtension() {
OSType osType = calculateOS();
switch (osType) {
case APPLE:
return "dylib";
case LINUX:
return "so";
case SUN:
return "so";
case WINDOWS:
return "dll";
}
return "";
}
/**
* Returns the prefix for dynamically linked libraries on the
* current OS. That is, returns "lib" on Apple, Linux and Sun,
* and the empty String on Windows.
*
* @return The library prefix
*/
private static String createLibPrefix() {
OSType osType = calculateOS();
switch (osType) {
case APPLE:
case LINUX:
case SUN:
return "lib";
case WINDOWS:
return "";
}
return "";
}
/**
* Creates the name for the native library with the given base
* name for the current operating system and architecture.
* The resulting name will be of the form
* baseName-OSType-ARCHType
* where OSType and ARCHType are the lower case Strings
* of the respective enum constants. Example:
* jcuda-windows-x86
*
* @param baseName The base name of the library
* @return The library name
*/
public static String createLibName(String baseName) {
OSType osType = calculateOS();
ARCHType archType = calculateArch();
String libName = baseName;
libName += "-" + osType.toString().toLowerCase(Locale.ENGLISH);
libName += "-" + archType.toString().toLowerCase(Locale.ENGLISH);
return libName;
}
/**
* Calculates the current OSType
*
* @return The current OSType
*/
public static OSType calculateOS() {
String osName = System.getProperty("os.name");
osName = osName.toLowerCase(Locale.ENGLISH);
if (osName.startsWith("mac os")) {
return OSType.APPLE;
}
if (osName.startsWith("windows")) {
return OSType.WINDOWS;
}
if (osName.startsWith("linux")) {
return OSType.LINUX;
}
if (osName.startsWith("sun")) {
return OSType.SUN;
}
return OSType.UNKNOWN;
}
/**
* Calculates the current ARCHType
*
* @return The current ARCHType
*/
public static ARCHType calculateArch() {
String osArch = System.getProperty("os.arch");
osArch = osArch.toLowerCase(Locale.ENGLISH);
if (osArch.equals("i386") || osArch.equals("x86") || osArch.equals("i686")) {
return ARCHType.X86;
}
if (osArch.startsWith("amd64") || osArch.startsWith("x86_64")) {
return ARCHType.X86_64;
}
if (osArch.equals("ppc") || osArch.equals("powerpc")) {
return ARCHType.PPC;
}
if (osArch.startsWith("ppc")) {
return ARCHType.PPC_64;
}
if (osArch.startsWith("sparc")) {
return ARCHType.SPARC;
}
if (osArch.startsWith("arm")) {
return ARCHType.ARM;
}
if (osArch.startsWith("mips")) {
return ARCHType.MIPS;
}
if (osArch.contains("risc")) {
return ARCHType.RISC;
}
return ARCHType.UNKNOWN;
}
/**
* Private constructor to prevent instantiation.
*/
private LibUtils() {}
}
