summaryrefslogtreecommitdiffstats
path: root/src/java/jogamp/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/java/jogamp/common')
-rw-r--r--src/java/jogamp/common/os/PlatformPropsImpl.java6
-rw-r--r--src/java/jogamp/common/util/Int32ArrayBitfield.java207
-rw-r--r--src/java/jogamp/common/util/Int32Bitfield.java163
-rw-r--r--src/java/jogamp/common/util/SyncedBitfield.java96
-rw-r--r--src/java/jogamp/common/util/locks/RecursiveLockImpl01CompleteFair.java4
-rw-r--r--src/java/jogamp/common/util/locks/RecursiveThreadGroupLockImpl01Unfairish.java34
-rw-r--r--src/java/jogamp/common/util/locks/SingletonInstanceFileLock.java4
-rw-r--r--src/java/jogamp/common/util/locks/SingletonInstanceServerSocket.java129
8 files changed, 581 insertions, 62 deletions
diff --git a/src/java/jogamp/common/os/PlatformPropsImpl.java b/src/java/jogamp/common/os/PlatformPropsImpl.java
index 0d0063c..097a013 100644
--- a/src/java/jogamp/common/os/PlatformPropsImpl.java
+++ b/src/java/jogamp/common/os/PlatformPropsImpl.java
@@ -63,6 +63,10 @@ public abstract class PlatformPropsImpl {
public static final VersionNumber Version16;
/** Version 1.7. As a JVM version, it enables certain JVM 1.7 features. */
public static final VersionNumber Version17;
+ /** Version 1.8. As a JVM version, it enables certain JVM 1.8 features. */
+ public static final VersionNumber Version18;
+ /** Version 1.9. As a JVM version, it enables certain JVM 1.9 features. */
+ public static final VersionNumber Version19;
public static final String OS;
public static final String OS_lower;
@@ -101,6 +105,8 @@ public abstract class PlatformPropsImpl {
static {
Version16 = new VersionNumber(1, 6, 0);
Version17 = new VersionNumber(1, 7, 0);
+ Version18 = new VersionNumber(1, 8, 0);
+ Version19 = new VersionNumber(1, 9, 0);
// We don't seem to need an AccessController.doPrivileged() block
// here as these system properties are visible even to unsigned Applets.
diff --git a/src/java/jogamp/common/util/Int32ArrayBitfield.java b/src/java/jogamp/common/util/Int32ArrayBitfield.java
new file mode 100644
index 0000000..5bc95eb
--- /dev/null
+++ b/src/java/jogamp/common/util/Int32ArrayBitfield.java
@@ -0,0 +1,207 @@
+/**
+ * Copyright 2015 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 jogamp.common.util;
+
+import com.jogamp.common.util.Bitfield;
+
+/**
+ * Simple bitfield interface for efficient storage access in O(1).
+ * <p>
+ * Implementation uses a 32bit integer array for storage.
+ * </p>
+ */
+public class Int32ArrayBitfield implements Bitfield {
+ private static final int UNIT_SHIFT = 5;
+ private final int[] storage;
+ private final int bitSize;
+
+ /**
+ * @param storageBitSize
+ */
+ public Int32ArrayBitfield(final int storageBitSize) {
+ final int units = Math.max(1, ( storageBitSize + 31 ) >>> UNIT_SHIFT);
+ this.storage = new int[units]; // initialized w/ default '0'
+ this.bitSize = units << UNIT_SHIFT;
+ }
+
+ @Override
+ public int size() {
+ return bitSize;
+ }
+
+ @Override
+ public final void clearField(final boolean bit) {
+ final int v;
+ if( bit ) {
+ v = Bitfield.UNSIGNED_INT_MAX_VALUE;
+ } else {
+ v = 0;
+ }
+ for(int i=storage.length-1; i>=0; i--) {
+ storage[i] = v;
+ }
+ }
+
+ private static final void check(final int size, final int bitnum) throws IndexOutOfBoundsException {
+ if( 0 > bitnum || bitnum >= size ) {
+ throw new IndexOutOfBoundsException("Bitnum should be within [0.."+(size-1)+"], but is "+bitnum);
+ }
+ }
+
+ @Override
+ public final int get32(final int lowBitnum, final int length) throws IndexOutOfBoundsException {
+ if( 0 > length || length > 32 ) {
+ throw new IndexOutOfBoundsException("length should be within [0..32], but is "+length);
+ }
+ check(bitSize-length+1, lowBitnum);
+ final int u = lowBitnum >>> UNIT_SHIFT;
+ final int left = 32 - ( lowBitnum - ( u << UNIT_SHIFT ) ); // remaining bits of first chunk storage
+ if( 32 == left ) {
+ // fast path
+ final int m = Util.getBitMask(length); // mask of chunk
+ return m & storage[u];
+ } else {
+ // slow path
+ final int l = Math.min(length, left); // length of first chunk < 32
+ final int m = ( 1 << l ) - 1; // mask of first chunk
+ final int d = m & ( storage[u] >>> lowBitnum );
+ final int l2 = length - l; // length of last chunk < 32
+ if( l2 > 0 ) {
+ final int m2 = ( 1 << l2 ) - 1; // mask of last chunk
+ return d | ( ( m2 & storage[u+1] ) << l );
+ } else {
+ return d;
+ }
+ }
+ }
+ @Override
+ public final void put32(final int lowBitnum, final int length, final int data) throws IndexOutOfBoundsException {
+ if( 0 > length || length > 32 ) {
+ throw new IndexOutOfBoundsException("length should be within [0..32], but is "+length);
+ }
+ check(bitSize-length+1, lowBitnum);
+ final int u = lowBitnum >>> UNIT_SHIFT;
+ final int left = 32 - ( lowBitnum - ( u << UNIT_SHIFT ) ); // remaining bits of first chunk storage
+ if( 32 == left ) {
+ // fast path
+ final int m = Util.getBitMask(length); // mask of chunk
+ storage[u] = ( ( ~m ) & storage[u] ) // keep non-written storage bits
+ | ( m & data ); // overwrite storage w/ used data bits
+ } else {
+ // slow path
+ final int l = Math.min(length, left); // length of first chunk < 32
+ final int m = ( 1 << l ) - 1; // mask of first chunk
+ storage[u] = ( ( ~( m << lowBitnum ) ) & storage[u] ) // keep non-written storage bits
+ | ( ( m & data ) << lowBitnum ); // overwrite storage w/ used data bits
+ final int l2 = length - l; // length of last chunk < 32
+ if( l2 > 0 ) {
+ final int m2 = ( 1 << l2 ) - 1; // mask of last chunk
+ storage[u+1] = ( ( ~m2 ) & storage[u+1] ) // keep non-written storage bits
+ | ( m2 & ( data >>> l ) ); // overwrite storage w/ used data bits
+ }
+ }
+ }
+ @Override
+ public final int copy32(final int srcBitnum, final int dstBitnum, final int length) throws IndexOutOfBoundsException {
+ final int data = get32(srcBitnum, length);
+ put32(dstBitnum, length, data);
+ return data;
+ }
+
+ @Override
+ public final boolean get(final int bitnum) throws IndexOutOfBoundsException {
+ check(bitSize, bitnum);
+ final int u = bitnum >>> UNIT_SHIFT;
+ final int b = bitnum - ( u << UNIT_SHIFT );
+ return 0 != ( storage[u] & ( 1 << b ) ) ;
+ }
+
+ @Override
+ public final boolean put(final int bitnum, final boolean bit) throws IndexOutOfBoundsException {
+ check(bitSize, bitnum);
+ final int u = bitnum >>> UNIT_SHIFT;
+ final int b = bitnum - ( u << UNIT_SHIFT );
+ final int m = 1 << b;
+ final boolean prev = 0 != ( storage[u] & m ) ;
+ if( prev != bit ) {
+ if( bit ) {
+ storage[u] |= m;
+ } else {
+ storage[u] &= ~m;
+ }
+ }
+ return prev;
+ }
+ @Override
+ public final void set(final int bitnum) throws IndexOutOfBoundsException {
+ check(bitSize, bitnum);
+ final int u = bitnum >>> UNIT_SHIFT;
+ final int b = bitnum - ( u << UNIT_SHIFT );
+ final int m = 1 << b;
+ storage[u] |= m;
+ }
+ @Override
+ public final void clear(final int bitnum) throws IndexOutOfBoundsException {
+ check(bitSize, bitnum);
+ final int u = bitnum >>> UNIT_SHIFT;
+ final int b = bitnum - ( u << UNIT_SHIFT );
+ final int m = 1 << b;
+ storage[u] &= ~m;
+ }
+ @Override
+ public final boolean copy(final int srcBitnum, final int dstBitnum) throws IndexOutOfBoundsException {
+ check(bitSize, srcBitnum);
+ check(bitSize, dstBitnum);
+ final boolean bit;
+ // get
+ {
+ final int u = srcBitnum >>> UNIT_SHIFT;
+ final int b = srcBitnum - ( u << UNIT_SHIFT );
+ bit = 0 != ( storage[u] & ( 1 << b ) ) ;
+ }
+ // put
+ final int u = dstBitnum >>> UNIT_SHIFT;
+ final int b = dstBitnum - ( u << UNIT_SHIFT );
+ final int m = 1 << b;
+ if( bit ) {
+ storage[u] |= m;
+ } else {
+ storage[u] &= ~m;
+ }
+ return bit;
+ }
+
+ @Override
+ public int bitCount() {
+ int c = 0;
+ for(int i = storage.length-1; i>=0; i--) {
+ c += Bitfield.Util.bitCount(storage[i]);
+ }
+ return c;
+ }
+}
diff --git a/src/java/jogamp/common/util/Int32Bitfield.java b/src/java/jogamp/common/util/Int32Bitfield.java
new file mode 100644
index 0000000..7b55a59
--- /dev/null
+++ b/src/java/jogamp/common/util/Int32Bitfield.java
@@ -0,0 +1,163 @@
+/**
+ * Copyright 2015 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 jogamp.common.util;
+
+import com.jogamp.common.util.Bitfield;
+
+/**
+ * Simple bitfield interface for efficient storage access in O(1).
+ * <p>
+ * Implementation uses one 32bit integer field for storage.
+ * </p>
+ */
+public class Int32Bitfield implements Bitfield {
+ /** Unit size in bits, here 32 bits for one int unit. */
+ private static final int UNIT_SIZE = 32;
+ private int storage;
+
+ public Int32Bitfield() {
+ this.storage = 0;
+ }
+
+ @Override
+ public int size() {
+ return UNIT_SIZE;
+ }
+
+ @Override
+ public final void clearField(final boolean bit) {
+ if( bit ) {
+ storage = Bitfield.UNSIGNED_INT_MAX_VALUE;
+ } else {
+ storage = 0;
+ }
+ }
+
+ private static final void check(final int size, final int bitnum) throws IndexOutOfBoundsException {
+ if( 0 > bitnum || bitnum >= size ) {
+ throw new IndexOutOfBoundsException("Bitnum should be within [0.."+(size-1)+"], but is "+bitnum);
+ }
+ }
+
+ @Override
+ public final int get32(final int lowBitnum, final int length) throws IndexOutOfBoundsException {
+ if( 0 > length || length > 32 ) {
+ throw new IndexOutOfBoundsException("length should be within [0..32], but is "+length);
+ }
+ check(UNIT_SIZE-length+1, lowBitnum);
+ final int left = 32 - lowBitnum; // remaining bits of first chunk
+ if( 32 == left ) {
+ // fast path
+ final int m = Util.getBitMask(length); // mask of chunk
+ return m & storage;
+ } else {
+ // slow path
+ final int l = Math.min(length, left); // length of first chunk < 32
+ final int m = ( 1 << l ) - 1; // mask of first chunk
+ return m & ( storage >>> lowBitnum );
+ }
+ }
+ @Override
+ public final void put32(final int lowBitnum, final int length, final int data) throws IndexOutOfBoundsException {
+ if( 0 > length || length > 32 ) {
+ throw new IndexOutOfBoundsException("length should be within [0..32], but is "+length);
+ }
+ check(UNIT_SIZE-length+1, lowBitnum);
+ final int left = 32 - lowBitnum; // remaining bits of first chunk storage
+ if( 32 == left ) {
+ // fast path
+ final int m = Util.getBitMask(length); // mask of chunk
+ storage = ( ( ~m ) & storage ) // keep non-written storage bits
+ | ( m & data ); // overwrite storage w/ used data bits
+ } else {
+ // slow path
+ final int l = Math.min(length, left); // length of first chunk < 32
+ final int m = ( 1 << l ) - 1; // mask of first chunk
+ storage = ( ( ~( m << lowBitnum ) ) & storage ) // keep non-written storage bits
+ | ( ( m & data ) << lowBitnum ); // overwrite storage w/ used data bits
+ }
+ }
+ @Override
+ public final int copy32(final int srcBitnum, final int dstBitnum, final int length) throws IndexOutOfBoundsException {
+ final int data = get32(srcBitnum, length);
+ put32(dstBitnum, length, data);
+ return data;
+ }
+
+ @Override
+ public final boolean get(final int bitnum) throws IndexOutOfBoundsException {
+ check(UNIT_SIZE, bitnum);
+ return 0 != ( storage & ( 1 << bitnum ) ) ;
+ }
+ @Override
+ public final boolean put(final int bitnum, final boolean bit) throws IndexOutOfBoundsException {
+ check(UNIT_SIZE, bitnum);
+ final int m = 1 << bitnum;
+ final boolean prev = 0 != ( storage & m ) ;
+ if( prev != bit ) {
+ if( bit ) {
+ storage |= m;
+ } else {
+ storage &= ~m;
+ }
+ }
+ return prev;
+ }
+ @Override
+ public final void set(final int bitnum) throws IndexOutOfBoundsException {
+ check(UNIT_SIZE, bitnum);
+ final int m = 1 << bitnum;
+ storage |= m;
+ }
+ @Override
+ public final void clear (final int bitnum) throws IndexOutOfBoundsException {
+ check(UNIT_SIZE, bitnum);
+ final int m = 1 << bitnum;
+ storage &= ~m;
+ }
+ @Override
+ public final boolean copy(final int srcBitnum, final int dstBitnum) throws IndexOutOfBoundsException {
+ check(UNIT_SIZE, srcBitnum);
+ check(UNIT_SIZE, dstBitnum);
+ // get
+ final boolean bit = 0 != ( storage & ( 1 << srcBitnum ) ) ;
+ // put
+ final int m = 1 << dstBitnum;
+ if( bit ) {
+ storage |= m;
+ } else {
+ storage &= ~m;
+ }
+ return bit;
+ }
+
+ @Override
+ public int bitCount() {
+ return Bitfield.Util.bitCount(storage);
+ }
+}
diff --git a/src/java/jogamp/common/util/SyncedBitfield.java b/src/java/jogamp/common/util/SyncedBitfield.java
new file mode 100644
index 0000000..49c27b0
--- /dev/null
+++ b/src/java/jogamp/common/util/SyncedBitfield.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2015 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 jogamp.common.util;
+
+import com.jogamp.common.util.Bitfield;
+
+/**
+ * Simple synchronized {@link Bitfield} by wrapping an existing {@link Bitfield}.
+ */
+public class SyncedBitfield implements Bitfield {
+ private final Bitfield impl;
+
+ public SyncedBitfield(final Bitfield impl) {
+ this.impl = impl;
+ }
+
+ @Override
+ public final synchronized int size() {
+ return impl.size();
+ }
+
+ @Override
+ public final synchronized void clearField(final boolean bit) {
+ impl.clearField(bit);
+ }
+
+ @Override
+ public final synchronized int get32(final int lowBitnum, final int length) throws IndexOutOfBoundsException {
+ return impl.get32(lowBitnum, length);
+ }
+
+ @Override
+ public final synchronized void put32(final int lowBitnum, final int length, final int data) throws IndexOutOfBoundsException {
+ impl.put32(lowBitnum, length, data);
+ }
+
+ @Override
+ public final synchronized int copy32(final int srcLowBitnum, final int dstLowBitnum, final int length) throws IndexOutOfBoundsException {
+ return impl.copy32(srcLowBitnum, dstLowBitnum, length);
+ }
+
+ @Override
+ public final synchronized boolean get(final int bitnum) throws IndexOutOfBoundsException {
+ return impl.get(bitnum);
+ }
+
+ @Override
+ public final synchronized boolean put(final int bitnum, final boolean bit) throws IndexOutOfBoundsException {
+ return impl.put(bitnum, bit);
+ }
+
+ @Override
+ public final synchronized void set(final int bitnum) throws IndexOutOfBoundsException {
+ impl.set(bitnum);
+ }
+
+ @Override
+ public final synchronized void clear(final int bitnum) throws IndexOutOfBoundsException {
+ impl.clear(bitnum);
+ }
+
+ @Override
+ public final synchronized boolean copy(final int srcBitnum, final int dstBitnum) throws IndexOutOfBoundsException {
+ return impl.copy(srcBitnum, dstBitnum);
+ }
+
+ @Override
+ public final synchronized int bitCount() {
+ return impl.bitCount();
+ }
+} \ No newline at end of file
diff --git a/src/java/jogamp/common/util/locks/RecursiveLockImpl01CompleteFair.java b/src/java/jogamp/common/util/locks/RecursiveLockImpl01CompleteFair.java
index c930dff..1286924 100644
--- a/src/java/jogamp/common/util/locks/RecursiveLockImpl01CompleteFair.java
+++ b/src/java/jogamp/common/util/locks/RecursiveLockImpl01CompleteFair.java
@@ -32,6 +32,7 @@ import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.AbstractOwnableSynchronizer;
+import com.jogamp.common.util.SourcedInterruptedException;
import com.jogamp.common.util.locks.RecursiveLock;
/**
@@ -197,7 +198,7 @@ public class RecursiveLockImpl01CompleteFair implements RecursiveLock {
} catch (final InterruptedException e) {
if( !wCur.signaledByUnlock ) {
sync.queue.remove(wCur); // O(n)
- throw e; // propagate interruption not send by unlock
+ throw SourcedInterruptedException.wrap(e); // propagate interruption not send by unlock
} else if( cur != sync.getOwner() ) {
// Issued by unlock, but still locked by other thread
//
@@ -215,6 +216,7 @@ public class RecursiveLockImpl01CompleteFair implements RecursiveLock {
} // else: Issued by unlock, owning lock .. expected!
}
} while ( cur != sync.getOwner() && 0 < timeout ) ;
+ Thread.interrupted(); // clear slipped interrupt
if( 0 >= timeout && cur != sync.getOwner() ) {
// timed out
diff --git a/src/java/jogamp/common/util/locks/RecursiveThreadGroupLockImpl01Unfairish.java b/src/java/jogamp/common/util/locks/RecursiveThreadGroupLockImpl01Unfairish.java
index 77f73d8..fc5f739 100644
--- a/src/java/jogamp/common/util/locks/RecursiveThreadGroupLockImpl01Unfairish.java
+++ b/src/java/jogamp/common/util/locks/RecursiveThreadGroupLockImpl01Unfairish.java
@@ -42,6 +42,7 @@ public class RecursiveThreadGroupLockImpl01Unfairish
threadNum = 0;
threads = null;
holdCountAdditionOwner = 0;
+ waitingOrigOwner = null;
}
@Override
public final void incrHoldCount(final Thread t) {
@@ -64,6 +65,12 @@ public class RecursiveThreadGroupLockImpl01Unfairish
public final boolean isOriginalOwner(final Thread t) {
return super.isOwner(t);
}
+ public final void setWaitingOrigOwner(final Thread origOwner) {
+ waitingOrigOwner = origOwner;
+ }
+ public final Thread getWaitingOrigOwner() {
+ return waitingOrigOwner;
+ }
@Override
public final boolean isOwner(final Thread t) {
if(getExclusiveOwnerThread()==t) {
@@ -133,6 +140,7 @@ public class RecursiveThreadGroupLockImpl01Unfairish
private int holdCountAdditionOwner;
private Thread[] threads;
private int threadNum;
+ private Thread waitingOrigOwner;
}
public RecursiveThreadGroupLockImpl01Unfairish() {
@@ -157,10 +165,10 @@ public class RecursiveThreadGroupLockImpl01Unfairish
final Thread cur = Thread.currentThread();
final ThreadGroupSync tgSync = (ThreadGroupSync)sync;
if(!tgSync.isOriginalOwner(cur)) {
- throw new IllegalArgumentException("Current thread is not the original owner: orig-owner: "+tgSync.getOwner()+", current "+cur);
+ throw new IllegalArgumentException("Current thread is not the original owner: orig-owner: "+tgSync.getOwner()+", current "+cur+": "+toString());
}
if(tgSync.isOriginalOwner(t)) {
- throw new IllegalArgumentException("Passed thread is original owner: "+t);
+ throw new IllegalArgumentException("Passed thread is original owner: "+t+", "+toString());
}
tgSync.addOwner(t);
}
@@ -179,19 +187,25 @@ public class RecursiveThreadGroupLockImpl01Unfairish
// original locking owner thread
if( tgSync.getHoldCount() - tgSync.getAdditionalOwnerHoldCount() == 1 ) {
// release orig. lock
- while ( tgSync.getAdditionalOwnerHoldCount() > 0 ) {
- try {
- sync.wait();
- } catch (final InterruptedException e) {
- // regular wake up!
+ tgSync.setWaitingOrigOwner(cur);
+ try {
+ while ( tgSync.getAdditionalOwnerHoldCount() > 0 ) {
+ try {
+ sync.wait();
+ } catch (final InterruptedException e) {
+ // regular wake up!
+ }
}
+ } finally {
+ tgSync.setWaitingOrigOwner(null);
+ Thread.interrupted(); // clear slipped interrupt
}
tgSync.removeAllOwners();
}
} else if( tgSync.getAdditionalOwnerHoldCount() == 1 ) {
- // last additional owner thread wakes up original owner
- final Thread originalOwner = tgSync.getOwner();
- if(originalOwner.getState() == Thread.State.WAITING) {
+ // last additional owner thread wakes up original owner if waiting in unlock(..)
+ final Thread originalOwner = tgSync.getWaitingOrigOwner();
+ if( null != originalOwner ) {
originalOwner.interrupt();
}
}
diff --git a/src/java/jogamp/common/util/locks/SingletonInstanceFileLock.java b/src/java/jogamp/common/util/locks/SingletonInstanceFileLock.java
index 44a5d28..9fe7966 100644
--- a/src/java/jogamp/common/util/locks/SingletonInstanceFileLock.java
+++ b/src/java/jogamp/common/util/locks/SingletonInstanceFileLock.java
@@ -32,6 +32,8 @@ import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
+
+import com.jogamp.common.util.InterruptSource;
import com.jogamp.common.util.locks.SingletonInstance;
public class SingletonInstanceFileLock extends SingletonInstance {
@@ -76,7 +78,7 @@ public class SingletonInstanceFileLock extends SingletonInstance {
private void setupFileCleanup() {
file.deleteOnExit();
- Runtime.getRuntime().addShutdownHook(new Thread() {
+ Runtime.getRuntime().addShutdownHook(new InterruptSource.Thread() {
@Override
public void run() {
if(isLocked()) {
diff --git a/src/java/jogamp/common/util/locks/SingletonInstanceServerSocket.java b/src/java/jogamp/common/util/locks/SingletonInstanceServerSocket.java
index b1b42c3..6219b5c 100644
--- a/src/java/jogamp/common/util/locks/SingletonInstanceServerSocket.java
+++ b/src/java/jogamp/common/util/locks/SingletonInstanceServerSocket.java
@@ -33,10 +33,16 @@ import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
+
+import com.jogamp.common.ExceptionUtils;
+import com.jogamp.common.util.InterruptSource;
+import com.jogamp.common.util.InterruptedRuntimeException;
+import com.jogamp.common.util.SourcedInterruptedException;
import com.jogamp.common.util.locks.SingletonInstance;
public class SingletonInstanceServerSocket extends SingletonInstance {
+ private static int serverInstanceCount = 0;
private final Server singletonServer;
private final String fullName;
@@ -71,7 +77,7 @@ public class SingletonInstanceServerSocket extends SingletonInstance {
fullName = ilh.toString()+":"+portNumber;
singletonServer = new Server(ilh, portNumber);
- Runtime.getRuntime().addShutdownHook(new Thread() {
+ Runtime.getRuntime().addShutdownHook(new InterruptSource.Thread() {
@Override
public void run() {
singletonServer.kill();
@@ -139,38 +145,58 @@ public class SingletonInstanceServerSocket extends SingletonInstance {
public final boolean start() {
if(alive) return true;
+ final String sname;
+ synchronized (Server.class) {
+ serverInstanceCount++;
+ sname = "SingletonServerSocket"+serverInstanceCount+"-"+fullName;
+ }
synchronized (syncOnStartStop) {
- serverThread = new Thread(this);
+ shallQuit = false;
+ serverThread = new InterruptSource.Thread(null, this, sname);
serverThread.setDaemon(true); // be a daemon, don't keep the JVM running
serverThread.start();
try {
- syncOnStartStop.wait();
+ while( !alive && !shallQuit ) {
+ syncOnStartStop.wait();
+ }
} catch (final InterruptedException ie) {
- ie.printStackTrace();
+ final InterruptedException ie2 = SourcedInterruptedException.wrap(ie);
+ shutdown(false);
+ throw new InterruptedRuntimeException(ie2);
}
}
final boolean ok = isBound();
if(!ok) {
- shutdown();
+ shutdown(true);
}
return ok;
}
public final boolean shutdown() {
+ return shutdown(true);
+ }
+ private final boolean shutdown(final boolean wait) {
if(!alive) return true;
- synchronized (syncOnStartStop) {
- shallQuit = true;
- connect();
- try {
- syncOnStartStop.wait();
- } catch (final InterruptedException ie) {
- ie.printStackTrace();
+ try {
+ synchronized (syncOnStartStop) {
+ shallQuit = true;
+ connect();
+ if( wait ) {
+ try {
+ while( alive ) {
+ syncOnStartStop.wait();
+ }
+ } catch (final InterruptedException ie) {
+ throw new InterruptedRuntimeException(ie);
+ }
+ }
+ }
+ } finally {
+ if(alive) {
+ System.err.println(infoPrefix()+" EEE "+getName()+" - Unable to remove lock: ServerThread still alive ?");
+ kill();
}
- }
- if(alive) {
- System.err.println(infoPrefix()+" EEE "+getName()+" - Unable to remove lock: ServerThread still alive ?");
- kill();
}
return true;
}
@@ -185,7 +211,8 @@ public class SingletonInstanceServerSocket extends SingletonInstance {
System.err.println(infoPrefix()+" XXX "+getName()+" - Kill @ JVM Shutdown");
}
alive = false;
- if(null != serverThread) {
+ shallQuit = false;
+ if(null != serverThread && serverThread.isAlive() ) {
try {
serverThread.stop();
} catch(final Throwable t) { }
@@ -214,47 +241,49 @@ public class SingletonInstanceServerSocket extends SingletonInstance {
@Override
public void run() {
- {
- final Thread currentThread = Thread.currentThread();
- currentThread.setName(currentThread.getName() + " - SISock: "+getName());
- if(DEBUG) {
- System.err.println(currentThread.getName()+" - started");
- }
+ if(DEBUG) {
+ System.err.println(infoPrefix()+" III - Start");
}
- alive = false;
- synchronized (syncOnStartStop) {
- try {
- serverSocket = new ServerSocket(portNumber, 1, localInetAddress);
- serverSocket.setReuseAddress(true); // reuse same port w/ subsequent instance, i.e. overcome TO state when JVM crashed
- alive = true;
- } catch (final IOException e) {
- System.err.println(infoPrefix()+" III - Unable to install ServerSocket: "+e.getMessage());
- shallQuit = true;
- } finally {
- syncOnStartStop.notifyAll();
+ try {
+ synchronized (syncOnStartStop) {
+ try {
+ serverSocket = new ServerSocket(portNumber, 1, localInetAddress);
+ serverSocket.setReuseAddress(true); // reuse same port w/ subsequent instance, i.e. overcome TO state when JVM crashed
+ alive = true;
+ } catch (final IOException e) {
+ System.err.println(infoPrefix()+" III - Unable to install ServerSocket: "+e.getMessage());
+ shallQuit = true;
+ } finally {
+ syncOnStartStop.notifyAll();
+ }
}
- }
- while (!shallQuit) {
- try {
- final Socket clientSocket = serverSocket.accept();
- clientSocket.close();
- } catch (final IOException ioe) {
- System.err.println(infoPrefix()+" EEE - Exception during accept: " + ioe.getMessage());
+ while (!shallQuit) {
+ try {
+ final Socket clientSocket = serverSocket.accept();
+ clientSocket.close();
+ } catch (final IOException ioe) {
+ System.err.println(infoPrefix()+" EEE - Exception during accept: " + ioe.getMessage());
+ }
}
- }
-
- synchronized (syncOnStartStop) {
- try {
+ } catch(final ThreadDeath td) {
+ if( DEBUG ) {
+ ExceptionUtils.dumpThrowable("", td);
+ }
+ } finally {
+ synchronized (syncOnStartStop) {
+ if(DEBUG) {
+ System.err.println(infoPrefix()+" III - Stopping: alive "+alive+", shallQuit "+shallQuit+", hasSocket "+(null!=serverSocket));
+ }
if(null != serverSocket) {
- serverSocket.close();
+ try {
+ serverSocket.close();
+ } catch (final IOException e) {
+ System.err.println(infoPrefix()+" EEE - Exception during close: " + e.getMessage());
+ }
}
- } catch (final IOException e) {
- System.err.println(infoPrefix()+" EEE - Exception during close: " + e.getMessage());
- } finally {
serverSocket = null;
alive = false;
- shallQuit = false;
syncOnStartStop.notifyAll();
}
}