aboutsummaryrefslogtreecommitdiffstats
path: root/src/java/com/jogamp/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/java/com/jogamp/common')
-rw-r--r--src/java/com/jogamp/common/impl/Debug.java25
-rw-r--r--src/java/com/jogamp/common/os/Platform.java48
-rw-r--r--src/java/com/jogamp/common/util/ReflectionUtil.java49
-rw-r--r--src/java/com/jogamp/common/util/locks/Lock.java77
-rw-r--r--src/java/com/jogamp/common/util/locks/LockExt.java50
-rw-r--r--src/java/com/jogamp/common/util/locks/RecursiveLock.java (renamed from src/java/com/jogamp/common/util/RecursiveToolkitLock.java)76
6 files changed, 276 insertions, 49 deletions
diff --git a/src/java/com/jogamp/common/impl/Debug.java b/src/java/com/jogamp/common/impl/Debug.java
index 06a5fea..d8412ae 100644
--- a/src/java/com/jogamp/common/impl/Debug.java
+++ b/src/java/com/jogamp/common/impl/Debug.java
@@ -56,18 +56,33 @@ public class Debug {
}
static int getIntProperty(final String property, final boolean jnlpAlias) {
- return getIntProperty(property, jnlpAlias, localACC);
+ return getIntProperty(property, jnlpAlias, localACC, 0);
}
- public static int getIntProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc) {
- int i=0;
+ public static int getIntProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc, int defaultValue) {
+ int i=defaultValue;
try {
- Integer iv = Integer.valueOf(Debug.getProperty(property, jnlpAlias, acc));
- i = iv.intValue();
+ String sv = Debug.getProperty(property, jnlpAlias, acc);
+ if(null!=sv) {
+ Integer iv = Integer.valueOf(sv);
+ i = iv.intValue();
+ }
} catch (NumberFormatException nfe) {}
return i;
}
+ public static long getLongProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc, long defaultValue) {
+ long l=defaultValue;
+ try {
+ String sv = Debug.getProperty(property, jnlpAlias, acc);
+ if(null!=sv) {
+ Long lv = Long.valueOf(sv);
+ l = lv.longValue();
+ }
+ } catch (NumberFormatException nfe) {}
+ return l;
+ }
+
static boolean getBooleanProperty(final String property, final boolean jnlpAlias) {
return getBooleanProperty(property, jnlpAlias, localACC);
}
diff --git a/src/java/com/jogamp/common/os/Platform.java b/src/java/com/jogamp/common/os/Platform.java
index 2b59d64..aac72af 100644
--- a/src/java/com/jogamp/common/os/Platform.java
+++ b/src/java/com/jogamp/common/os/Platform.java
@@ -48,7 +48,12 @@ public class Platform {
public static final boolean JAVA_SE;
public static final boolean LITTLE_ENDIAN;
public static final String OS;
+ public static final String OS_VERSION;
public static final String ARCH;
+ public static final String JAVA_VENDOR;
+ public static final String JAVA_VENDOR_URL;
+ public static final String JAVA_VERSION;
+ public static final String NEWLINE;
private static final boolean is32Bit;
private static final int pointerSizeInBits;
@@ -60,7 +65,12 @@ public class Platform {
// here as these system properties are visible even to unsigned
// applets
OS = System.getProperty("os.name");
+ OS_VERSION = System.getProperty("os.version");
ARCH = System.getProperty("os.arch");
+ JAVA_VENDOR = System.getProperty("java.vendor");
+ JAVA_VENDOR_URL = System.getProperty("java.vendor.url");
+ JAVA_VERSION = System.getProperty("java.version");
+ NEWLINE = System.getProperty("line.separator");
pointerSizeInBits = getPointerSizeInBitsImpl();
is32Bit = initArch();
@@ -119,7 +129,7 @@ public class Platform {
}
// probe for classes we need on a SE environment
- try{
+ try {
Class.forName("java.nio.LongBuffer");
Class.forName("java.nio.DoubleBuffer");
return true;
@@ -163,6 +173,14 @@ public class Platform {
}
/**
+ * Returns the OS version.
+ */
+ public static String getOSVersion() {
+ return OS_VERSION;
+ }
+
+
+ /**
* Returns the CPU architecture String.
*/
public static String getArch() {
@@ -170,6 +188,34 @@ public class Platform {
}
/**
+ * Returns the JAVA vendor
+ */
+ public static String getJavaVendor() {
+ return JAVA_VENDOR;
+ }
+
+ /**
+ * Returns the JAVA vendor url
+ */
+ public static String getJavaVendorURL() {
+ return JAVA_VENDOR_URL;
+ }
+
+ /**
+ * Returns the JAVA vendor
+ */
+ public static String getJavaVersion() {
+ return JAVA_VERSION;
+ }
+
+ /**
+ * Returns the JAVA vendor
+ */
+ public static String getNewline() {
+ return NEWLINE;
+ }
+
+ /**
* Returns true if this JVM is a 32bit JVM.
*/
public static boolean is32Bit() {
diff --git a/src/java/com/jogamp/common/util/ReflectionUtil.java b/src/java/com/jogamp/common/util/ReflectionUtil.java
index a04ec73..bf4624f 100644
--- a/src/java/com/jogamp/common/util/ReflectionUtil.java
+++ b/src/java/com/jogamp/common/util/ReflectionUtil.java
@@ -42,7 +42,9 @@ import com.jogamp.common.impl.Debug;
public final class ReflectionUtil {
- public static final boolean DEBUG = Debug.debug("ReflectionUtil");
+ public static final boolean DEBUG = Debug.debug("ReflectionUtil");
+
+ private static final Class[] zeroTypes = new Class[0];
/**
* Returns true only if the class could be loaded.
@@ -87,12 +89,14 @@ public final class ReflectionUtil {
static final String asString(Class[] argTypes) {
StringBuffer args = new StringBuffer();
boolean coma = false;
- for (int i = 0; i < argTypes.length; i++) {
- if(coma) {
- args.append(", ");
+ if(null != argTypes) {
+ for (int i = 0; i < argTypes.length; i++) {
+ if(coma) {
+ args.append(", ");
+ }
+ args.append(argTypes[i].getName());
+ coma = true;
}
- args.append(argTypes[i].getName());
- coma = true;
}
return args.toString();
}
@@ -103,6 +107,9 @@ public final class ReflectionUtil {
public static final Constructor getConstructor(Class clazz, Class[] cstrArgTypes)
throws JogampRuntimeException {
try {
+ if(null == cstrArgTypes) {
+ cstrArgTypes = zeroTypes;
+ }
return clazz.getDeclaredConstructor(cstrArgTypes);
} catch (NoSuchMethodException ex) {
throw new JogampRuntimeException("Constructor: '" + clazz + "(" + asString(cstrArgTypes) + ")' not found", ex);
@@ -111,7 +118,7 @@ public final class ReflectionUtil {
public static final Constructor getConstructor(String clazzName, ClassLoader cl)
throws JogampRuntimeException {
- return getConstructor(clazzName, new Class[0], cl);
+ return getConstructor(clazzName, null, cl);
}
/**
@@ -140,9 +147,12 @@ public final class ReflectionUtil {
public static final Object createInstance(Class clazz, Object[] cstrArgs)
throws JogampRuntimeException, RuntimeException
{
- Class[] cstrArgTypes = new Class[cstrArgs.length];
- for(int i=0; i<cstrArgs.length; i++) {
- cstrArgTypes[i] = cstrArgs[i].getClass();
+ Class[] cstrArgTypes = null;
+ if(null!=cstrArgs) {
+ cstrArgTypes = new Class[cstrArgs.length];
+ for(int i=0; i<cstrArgs.length; i++) {
+ cstrArgTypes[i] = cstrArgs[i].getClass();
+ }
}
return createInstance(clazz, cstrArgTypes, cstrArgs);
}
@@ -160,9 +170,12 @@ public final class ReflectionUtil {
public static final Object createInstance(String clazzName, Object[] cstrArgs, ClassLoader cl)
throws JogampRuntimeException, RuntimeException
{
- Class[] cstrArgTypes = new Class[cstrArgs.length];
- for(int i=0; i<cstrArgs.length; i++) {
- cstrArgTypes[i] = cstrArgs[i].getClass();
+ Class[] cstrArgTypes = null;
+ if(null!=cstrArgs) {
+ cstrArgTypes = new Class[cstrArgs.length];
+ for(int i=0; i<cstrArgs.length; i++) {
+ cstrArgTypes[i] = cstrArgs[i].getClass();
+ }
}
return createInstance(clazzName, cstrArgTypes, cstrArgs, cl);
}
@@ -170,7 +183,7 @@ public final class ReflectionUtil {
public static final Object createInstance(String clazzName, ClassLoader cl)
throws JogampRuntimeException, RuntimeException
{
- return createInstance(clazzName, new Class[0], null, cl);
+ return createInstance(clazzName, null, null, cl);
}
public static final boolean instanceOf(Object obj, String clazzName) {
@@ -239,8 +252,12 @@ public final class ReflectionUtil {
}
/**
- * @throws JogampRuntimeException if the call fails
- * @throws RuntimeException if the call fails
+ * @param instance may be null in case of a static method
+ * @param method the method to be called
+ * @param args the method arguments
+ * @return the methods result, maybe null if void
+ * @throws JogampRuntimeException if call fails
+ * @throws RuntimeException if call fails
*/
public static final Object callMethod(Object instance, Method method, Object[] args)
throws JogampRuntimeException, RuntimeException
diff --git a/src/java/com/jogamp/common/util/locks/Lock.java b/src/java/com/jogamp/common/util/locks/Lock.java
new file mode 100644
index 0000000..7065ff8
--- /dev/null
+++ b/src/java/com/jogamp/common/util/locks/Lock.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util.locks;
+
+import com.jogamp.common.impl.Debug;
+import java.security.AccessController;
+
+/**
+ * Specifying a thread blocking lock implementation
+ */
+public interface Lock {
+
+ /** Enable via the property <code>jogamp.debug.Lock</code> */
+ public static final boolean DEBUG = Debug.debug("Lock");
+
+ /** Defines the default {@link #TIMEOUT} value */
+ public static final long DEFAULT_TIMEOUT = 5000; // 5s default timeout
+
+ /**
+ * Defines the <code>TIMEOUT</code> for {@link #lock()} in ms,
+ * and defaults to {@link #DEFAULT_TIMEOUT}.<br>
+ * It can be overriden via the system property <code>jogamp.common.utils.locks.Lock.timeout</code>.
+ */
+ public static final long TIMEOUT = Debug.getLongProperty("jogamp.common.utils.locks.Lock.timeout", true, AccessController.getContext(), DEFAULT_TIMEOUT);
+
+ /**
+ * Blocking until the lock is acquired by this Thread or {@link #TIMEOUT} is reached.
+ *
+ * @throws RuntimeException in case of {@link #TIMEOUT}
+ */
+ void lock() throws RuntimeException;
+
+ /**
+ * Blocking until the lock is acquired by this Thread or <code>maxwait</code> in ms is reached.
+ *
+ * @param maxwait Maximum time in ms to wait to acquire the lock. If this value is zero,
+ * the call returns immediately either without being able
+ * to acquire the lock, or with acquiring the lock directly while ignoring any scheduling order.
+ * @return true if the lock has been acquired within <code>maxwait</code>, otherwise false
+ *
+ * @throws RuntimeException in case of {@link #TIMEOUT}
+ */
+ boolean tryLock(long maxwait) throws RuntimeException;
+
+ /**
+ * Unblocking.
+ *
+ * @throws RuntimeException in case the lock is not acquired by this thread.
+ */
+ void unlock() throws RuntimeException;
+}
diff --git a/src/java/com/jogamp/common/util/locks/LockExt.java b/src/java/com/jogamp/common/util/locks/LockExt.java
new file mode 100644
index 0000000..42a01c6
--- /dev/null
+++ b/src/java/com/jogamp/common/util/locks/LockExt.java
@@ -0,0 +1,50 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+package com.jogamp.common.util.locks;
+
+/**
+ * Extending the {@link Lock} features with convenient functionality.
+ */
+public interface LockExt extends Lock {
+
+ /**
+ * @return the Thread owning this lock if locked, otherwise null
+ */
+ Thread getOwner();
+
+ boolean isLocked();
+
+ boolean isLockedByOtherThread();
+
+ boolean isOwner();
+
+ boolean isOwner(Thread thread);
+
+ void validateLocked();
+}
diff --git a/src/java/com/jogamp/common/util/RecursiveToolkitLock.java b/src/java/com/jogamp/common/util/locks/RecursiveLock.java
index e02ff94..010467b 100644
--- a/src/java/com/jogamp/common/util/RecursiveToolkitLock.java
+++ b/src/java/com/jogamp/common/util/locks/RecursiveLock.java
@@ -26,23 +26,25 @@
* or implied, of JogAmp Community.
*/
-package com.jogamp.common.util;
+package com.jogamp.common.util.locks;
import com.jogamp.common.impl.Debug;
+import java.security.AccessController;
import java.util.LinkedList;
/**
* Reentrance locking toolkit, impl a complete fair FIFO scheduler
*/
-public class RecursiveToolkitLock {
+public class RecursiveLock implements LockExt {
+
static class SyncData {
// owner of the lock
Thread owner = null;
// lock recursion
int recursionCount = 0;
- // stack trace of the lock
- Exception lockedStack = null;
+ // stack trace of the lock, only used if DEBUG
+ Throwable lockedStack = null;
// waiting thread queue
LinkedList threadQueue = new LinkedList();
// flag signaling unlock has woken up a waiting thread
@@ -50,20 +52,17 @@ public class RecursiveToolkitLock {
}
private SyncData sdata = new SyncData(); // synchronized (flow/mem) mutable access
- private long timeout;
- private static final long defaultTimeout = 5000; // default maximum wait 5s
- // private static final long defaultTimeout = 300000; // default maximum wait 300s / 5min
- private static final boolean TRACE_LOCK = Debug.debug("TraceLock");
-
- public RecursiveToolkitLock() {
- this.timeout = defaultTimeout;
- }
+ private static final boolean TRACE_LOCK = Debug.isPropertyDefined("jogamp.debug.Lock.TraceLock", true, AccessController.getContext());
- public RecursiveToolkitLock(long timeout) {
- this.timeout = timeout;
+ public RecursiveLock() {
}
- public final Exception getLockedStack() {
+ /**
+ * Returns the Throwable instance generated when this lock was taken the 1st time
+ * and if {@link com.jogamp.common.util.locks.Lock#DEBUG} is turned on, otherwise it returns always <code>null</code>.
+ * @see com.jogamp.common.util.locks.Lock#DEBUG
+ */
+ public final Throwable getLockedStack() {
synchronized(sdata) {
return sdata.lockedStack;
}
@@ -109,32 +108,55 @@ public class RecursiveToolkitLock {
throw new RuntimeException(Thread.currentThread()+": Not locked");
}
if ( Thread.currentThread() != sdata.owner ) {
- getLockedStack().printStackTrace();
+ if(null!=sdata.lockedStack) {
+ sdata.lockedStack.printStackTrace();
+ }
throw new RuntimeException(Thread.currentThread()+": Not owner, owner is "+sdata.owner);
}
}
}
- /** Recursive and blocking lockSurface() implementation */
public final void lock() {
synchronized(sdata) {
+ if(!tryLock(TIMEOUT)) {
+ if(null!=sdata.lockedStack) {
+ sdata.lockedStack.printStackTrace();
+ }
+ throw new RuntimeException("Waited "+TIMEOUT+"ms for: "+sdata.owner+" - "+Thread.currentThread()+", with recursionCount "+sdata.recursionCount+", lock: "+this+", qsz "+sdata.threadQueue.size());
+ }
+ }
+ }
+
+ public boolean tryLock(long maxwait) {
+ synchronized(sdata) {
Thread cur = Thread.currentThread();
+ if(TRACE_LOCK) {
+ Throwable tt = new Throwable("LOCK 0 ["+this+"], recursions "+sdata.recursionCount+", cur "+cur+", owner "+sdata.owner);
+ tt.printStackTrace();
+ }
if (sdata.owner == cur) {
++sdata.recursionCount;
if(TRACE_LOCK) {
System.err.println("+++ LOCK 2 ["+this+"], recursions "+sdata.recursionCount+", "+cur);
}
- return;
+ return true;
}
- if (sdata.owner != null || sdata.signaled || sdata.threadQueue.size() > 0) {
- // enqueue due to locked resource or already waiting or signaled threads (be fair)
+ if ( sdata.owner != null ||
+ 0 < maxwait && ( sdata.signaled || sdata.threadQueue.size() > 0 ) ) {
+
+ if ( 0 >= maxwait ) {
+ // implies 'sdata.owner != null': locked by other thread
+ // no waiting requested, bail out right away
+ return false;
+ }
+
boolean timedOut = false;
do {
sdata.threadQueue.addFirst(cur); // should only happen once
try {
- sdata.wait(timeout);
- timedOut = sdata.threadQueue.remove(cur); // timeout if not already removed by unlock
+ sdata.wait(maxwait);
+ timedOut = sdata.threadQueue.remove(cur); // TIMEOUT if not already removed by unlock
} catch (InterruptedException e) {
if(!sdata.signaled) {
// theoretically we could stay in the loop,
@@ -151,8 +173,7 @@ public class RecursiveToolkitLock {
sdata.signaled = false;
if(timedOut || null != sdata.owner) {
- sdata.lockedStack.printStackTrace();
- throw new RuntimeException("Waited "+timeout+"ms for: "+sdata.owner+" - "+cur+", with recursionCount "+sdata.recursionCount+", lock: "+this+", qsz "+sdata.threadQueue.size());
+ return false;
}
if(TRACE_LOCK) {
@@ -163,17 +184,18 @@ public class RecursiveToolkitLock {
}
sdata.owner = cur;
- sdata.lockedStack = new Exception("Previously locked by "+sdata.owner+", lock: "+this);
+ if(DEBUG) {
+ sdata.lockedStack = new Throwable("Previously locked by "+sdata.owner+", lock: "+this);
+ }
+ return true;
}
}
- /** Recursive and unblocking unlockSurface() implementation */
public final void unlock() {
unlock(null);
}
- /** Recursive and unblocking unlockSurface() implementation */
public final void unlock(Runnable taskAfterUnlockBeforeNotify) {
synchronized(sdata) {
validateLocked();
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 05:42:42 +0000