GLContext*/GLDrawableHelper: Fix consistency of recursive makeCurrent()/release()/destroy() calls ; Enable context switch tracing ; GLCanvas: proper AbstractGraphicsDevice destruction

GLContext*/GLDrawableHelper: Fix consistency of recursive makeCurrent()/release()/destroy() calls
  Utilizing volatile and lock.tryLock(0) for lockConsiderFailFast(),
  reducing redundant synchronization and using RecursiveLock implicit sync.

  GLContext 'early-out' is the case where the thread already holds the
  context, ie. context is already current and the native makeCurrent is skipped.

  makeCurrent()'s 'early-out' w/o incr. the recursive lock of GLContext
  and it's NativeSurface could lead to asymetry in lock/unlock count
  with release()/destroy() calls. The 1st release actually released the
  native ctx already.
  Properly utilize recursive lock/unlock in all cases and impl. 'early-out' after locking.

  Following the above in GLDrawableHelper.invokeGL()'s 'early-out' case as well,
  ie calling makeCurrent()/release() symmetrical.

  Introduce GLDrawableHelper.disposeGL(), which issues dispose on all GLEventListeners
  within a current context and issued context destruction directly.
  This simplifies GLAutodrawable's destroy/dispose calls and ensures
  that the above sequence of events happens atomically (lock is being hold until destruction).

Enable context switch tracing
  If property 'jogl.debug.GLContext.TraceSwitch' is defined, trace context switch.

GLCanvas: proper AbstractGraphicsDevice destruction

5 files changed, 318 insertions, 174 deletions

diff --git a/src/jogl/classes/jogamp/opengl/GLContextImpl.java b/src/jogl/classes/jogamp/opengl/GLContextImpl.java
index 28bb11f1e..4701ab544 100644
--- a/src/jogl/classes/jogamp/opengl/GLContextImpl.java
+++ b/src/jogl/classes/jogamp/opengl/GLContextImpl.java
@@ -69,6 +69,8 @@ import javax.media.opengl.GLPipelineFactory;
 import javax.media.opengl.GLProfile;
 
 public abstract class GLContextImpl extends GLContext {
+  public static final boolean TRACE_SWITCH = Debug.isPropertyDefined("jogl.debug.GLContext.TraceSwitch", true);
+  
   // RecursiveLock maintains a queue of waiting Threads, ensuring the longest waiting thread will be notified at unlock.  
   protected RecursiveLock lock = LockFactory.createRecursiveLock();
 
@@ -213,74 +215,94 @@ public abstract class GLContextImpl extends GLContext {
    */
   protected void drawableUpdatedNotify() throws GLException { }
 
-  boolean lockFailFast = true;
-  Object lockFailFastSync = new Object();
+  volatile boolean lockFailFast = true;
   
   public boolean isSynchronized() {
-    synchronized (lockFailFastSync) {
-        return !lockFailFast;
-    }
+    return !lockFailFast; // volatile: ok
   }
 
   public void setSynchronized(boolean isSynchronized) {
-    synchronized (lockFailFastSync) {
-        lockFailFast = !isSynchronized;
-    }
+    lockFailFast = !isSynchronized; // volatile: ok
   }
 
-  private final void lockConsiderFailFast()  {
-      synchronized (lockFailFastSync) {
-          if(lockFailFast && lock.isLockedByOtherThread()) {
-                throw new GLException("Error: Attempt to make context current on thread " + Thread.currentThread() +
-                                      " which is already current on thread " + lock.getOwner());
+  private final void lockConsiderFailFast() {
+      if( lockFailFast ) { // volatile: ok
+          try {
+              if( !lock.tryLock(0) ) { // immediate return w/ false, if lock is already held by other thread
+                    throw new GLException("Error: Attempt to make context current on thread " + Thread.currentThread().getName() +
+                                          " which is already current on thread " + lock.getOwner().getName());              
+              }
+          } catch (InterruptedException ie) {
+              throw new GLException(ie);
           }
+      } else {
+          lock.lock();
       }
-      lock.lock();
   }
     
   public abstract Object getPlatformGLExtensions();
 
   // Note: the surface is locked within [makeCurrent .. swap .. release]
   public void release() throws GLException {
+    release(false);
+  }
+  private void release(boolean force) throws GLException {
     if ( !lock.isOwner() ) {
       throw new GLException("Context not current on current thread");
     }
-    setCurrent(null);
+    final boolean actualRelease = force || lock.getHoldCount() == 1 ;
     try {
-        releaseImpl();
+        if( actualRelease ) {
+            setCurrent(null);
+            if (contextHandle != 0) { // allow dbl-release
+                releaseImpl();
+            }
+        }
     } finally {
-      if (drawable.isSurfaceLocked()) {
-          drawable.unlockSurface();
-      }
+      drawable.unlockSurface();
       lock.unlock();
+      if(TRACE_SWITCH) {
+          if( actualRelease ) {
+              System.err.println("GLContext.ContextSwitch: - switch - CONTEXT_RELEASE - "+Thread.currentThread().getName()+" - "+lock);
+          } else {
+              System.err.println("GLContext.ContextSwitch: - keep   - CONTEXT_RELEASE - "+Thread.currentThread().getName()+" - "+lock);
+          }              
+      }
     }
   }
   protected abstract void releaseImpl() throws GLException;
 
   public final void destroy() {
-    if ( lock.isOwner() ) {
-        // release current context
-        if(null != glDebugHandler) {
-            glDebugHandler.enable(false);
-        }
-        release();
-    }
-
     // Must hold the lock around the destroy operation to make sure we
     // don't destroy the context out from under another thread rendering to it
-    lockConsiderFailFast();
+    lockConsiderFailFast(); // holdCount++ -> 1 or 2
     try {
+      if(lock.getHoldCount() > 2) {
+          throw new GLException("XXX: "+lock);
+      }
+      if (DEBUG || TRACE_SWITCH) {
+          System.err.println("GLContextImpl.destroy.0: " + toHexString(contextHandle) +
+                  ", isShared "+GLContextShareSet.isShared(this)+" - "+lock);
+      }
       if (contextHandle != 0) {
           int lockRes = drawable.lockSurface();
           if (NativeSurface.LOCK_SURFACE_NOT_READY == lockRes) {
                 // this would be odd ..
                 throw new GLException("Surface not ready to lock: "+drawable);
           }
-          try {
-              if (DEBUG) {
-                  System.err.println("GLContextImpl.destroy: " + toHexString(contextHandle) +
-                          ", isShared "+GLContextShareSet.isShared(this));
+          // release current context
+          if(null != glDebugHandler) {
+              if(lock.getHoldCount() == 1) {
+                  // needs current context to disable debug handler
+                  makeCurrent();
               }
+              glDebugHandler.enable(false);
+          }
+          if(lock.getHoldCount() > 1) {
+              // pending release() after makeCurrent()
+              release(true); 
+          }
+          try {
               destroyImpl();
               contextHandle = 0;
               glDebugHandler = null;
@@ -294,6 +316,10 @@ public abstract class GLContextImpl extends GLContext {
       }
     } finally {
       lock.unlock();
+      if (DEBUG || TRACE_SWITCH) {
+          System.err.println("GLContextImpl.destroy.X: " + toHexString(contextHandle) +
+                  ", isShared "+GLContextShareSet.isShared(this)+" - "+lock);
+      }
     }
 
     resetStates();
@@ -362,55 +388,75 @@ public abstract class GLContextImpl extends GLContext {
    * @see #destroyContextARBImpl
    */
   public int makeCurrent() throws GLException {
-    // One context can only be current by one thread,
-    // and one thread can only have one context current!
-    final GLContext current = getCurrent();
-    if (current != null) {
-      if (current == this) {
-        // Assume we don't need to make this context current again
-        // For Mac OS X, however, we need to update the context to track resizes
-        drawableUpdatedNotify();
-        return CONTEXT_CURRENT;
-      } else {
-        current.release();
-      }
-    }
-
-    if (GLWorkerThread.isStarted() &&
-        !GLWorkerThread.isWorkerThread()) {
-      // Kick the GLWorkerThread off its current context
-      GLWorkerThread.invokeLater(new Runnable() { public void run() {} });
-    }
-
-    if (!isCreated()) {
-        // verify if the drawable has chosen Capabilities
-        if (null == getGLDrawable().getChosenGLCapabilities()) {
-            throw new GLException("drawable has no chosen GLCapabilities: "+getGLDrawable());
-        }
-        if(DEBUG_GL) {
-            // only impacts w/ createContextARB(..)
-            additionalCtxCreationFlags |= GLContext.CTX_OPTION_DEBUG ;
-        }
-    }
-
+    boolean unlockContextAndDrawable = false;
     lockConsiderFailFast();
-    int res = 0;
+    int res = CONTEXT_NOT_CURRENT;
     try {
-      res = makeCurrentLocking();
-
-      /* FIXME: refactor dependence on Java 2D / JOGL bridge
-      if ((tracker != null) &&
-          (res == CONTEXT_CURRENT_NEW)) {
-        // Increase reference count of GLObjectTracker
-        tracker.ref();
-      }
-      */
-    } catch (GLException e) {
-      lock.unlock();
-      throw(e);
+        // Note: the surface is locked within [makeCurrent .. swap .. release]
+        int lockRes = drawable.lockSurface();
+        if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
+            return CONTEXT_NOT_CURRENT;
+        }
+        try {
+            if (NativeSurface.LOCK_SURFACE_CHANGED == lockRes) {
+                drawable.updateHandle();
+            }
+            // One context can only be current by one thread,
+            // and one thread can only have one context current!
+            final GLContext current = getCurrent();
+            if (current != null) {
+                if (current == this) {
+                    // Assume we don't need to make this context current again
+                    // For Mac OS X, however, we need to update the context to track resizes
+                    drawableUpdatedNotify();
+                    if(TRACE_SWITCH) {
+                        System.err.println("GLContext.ContextSwitch: - keep   - CONTEXT_CURRENT - "+Thread.currentThread().getName()+" - "+lock);
+                    }
+                    return CONTEXT_CURRENT;
+                } else {
+                    current.release();
+                }
+            }            
+            if (GLWorkerThread.isStarted() &&
+                !GLWorkerThread.isWorkerThread()) {
+                // Kick the GLWorkerThread off its current context
+                GLWorkerThread.invokeLater(new Runnable() { public void run() {} });
+            }
+    
+            if (0 == drawable.getHandle()) {
+                throw new GLException("drawable has invalid handle: "+drawable);
+            }
+            res = makeCurrentWithinLock(lockRes);
+            unlockContextAndDrawable = CONTEXT_NOT_CURRENT == res;
+            
+            /**
+             * FIXME: refactor dependence on Java 2D / JOGL bridge
+                if ((tracker != null) &&
+                    (res == CONTEXT_CURRENT_NEW)) {
+                    // Increase reference count of GLObjectTracker
+                    tracker.ref();
+                }
+             */
+        } catch (RuntimeException e) {
+          unlockContextAndDrawable = true;
+          throw e;
+        } finally {
+          if (unlockContextAndDrawable) {
+            drawable.unlockSurface();
+          }            
+        }
+    } catch (RuntimeException e) {
+      unlockContextAndDrawable = true;
+      throw e;
+    } finally {
+      if (unlockContextAndDrawable) {
+        lock.unlock();
+      }            
     }
     if (res == CONTEXT_NOT_CURRENT) {
-      lock.unlock();
+      if(TRACE_SWITCH) {
+          System.err.println("GLContext.ContextSwitch: - switch - CONTEXT_NOT_CURRENT - "+Thread.currentThread().getName()+" - "+lock);
+      }
     } else {
       setCurrent(this);
       if(res == CONTEXT_CURRENT_NEW) {
@@ -429,6 +475,11 @@ public abstract class GLContextImpl extends GLContext {
         if(TRACE_GL) {
             gl = gl.getContext().setGL( GLPipelineFactory.create("javax.media.opengl.Trace", null, gl, new Object[] { System.err } ) );
         }               
+        if(TRACE_SWITCH) {
+            System.err.println("GLContext.ContextSwitch: - switch - CONTEXT_CURRENT_NEW - "+Thread.currentThread().getName()+" - "+lock);
+        }
+      } else if(TRACE_SWITCH) {
+        System.err.println("GLContext.ContextSwitch: - switch - CONTEXT_CURRENT - "+Thread.currentThread().getName()+" - "+lock);
       }
 
       /* FIXME: refactor dependence on Java 2D / JOGL bridge
@@ -443,66 +494,47 @@ public abstract class GLContextImpl extends GLContext {
     return res;
   }
 
-  // Note: the surface is locked within [makeCurrent .. swap .. release]
-  protected final int makeCurrentLocking() throws GLException {
-    boolean shallUnlockSurface = false;
-    int lockRes = drawable.lockSurface();
-    try {
-      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
-        return CONTEXT_NOT_CURRENT;
-      }
-      try {
-          if (NativeSurface.LOCK_SURFACE_CHANGED == lockRes) {
-            drawable.updateHandle();
-          }
-          if (0 == drawable.getHandle()) {
-              throw new GLException("drawable has invalid handle: "+drawable);
-          }
-          if (!isCreated()) {
-            final GLContextImpl shareWith = (GLContextImpl) GLContextShareSet.getShareContext(this);
+  private final int makeCurrentWithinLock(int surfaceLockRes) throws GLException {
+      if (!isCreated()) {
+        if(DEBUG_GL) {
+            // only impacts w/ createContextARB(..)
+            additionalCtxCreationFlags |= GLContext.CTX_OPTION_DEBUG ;
+        }
+    
+        final GLContextImpl shareWith = (GLContextImpl) GLContextShareSet.getShareContext(this);
+        if (null != shareWith) {
+            shareWith.getDrawableImpl().lockSurface();
+        }
+        final boolean created;
+        try {
+            created = createImpl(shareWith); // may throws exception if fails!
+        } finally {
             if (null != shareWith) {
-                shareWith.getDrawableImpl().lockSurface();
-            }
-            boolean created;
-            try {
-                created = createImpl(shareWith); // may throws exception if fails!
-            } finally {
-                if (null != shareWith) {
-                    shareWith.getDrawableImpl().unlockSurface();
-                }                
-            }
-            if (DEBUG) {
-                if(created) {
-                    System.err.println(getThreadName() + ": !!! Create GL context OK: " + toHexString(contextHandle) + " for " + getClass().getName());
-                } else {
-                    System.err.println(getThreadName() + ": !!! Create GL context FAILED for " + getClass().getName());
-                }
-            }
-            if(!created) {
-                shallUnlockSurface = true;
-                return CONTEXT_NOT_CURRENT;
+                shareWith.getDrawableImpl().unlockSurface();
+            }                
+        }
+        if (DEBUG) {
+            if(created) {
+                System.err.println(getThreadName() + ": !!! Create GL context OK: " + toHexString(contextHandle) + " for " + getClass().getName());
+            } else {
+                System.err.println(getThreadName() + ": !!! Create GL context FAILED for " + getClass().getName());
             }
-            GLContextShareSet.contextCreated(this);
-            return CONTEXT_CURRENT_NEW;
-          }
-          makeCurrentImpl();
-          return CONTEXT_CURRENT;
-      } catch (RuntimeException e) {
-        shallUnlockSurface = true;
-        throw e;
-      }
-    } finally {
-      if (shallUnlockSurface) {
-        drawable.unlockSurface();
+        }
+        if(!created) {
+            return CONTEXT_NOT_CURRENT;
+        }
+        GLContextShareSet.contextCreated(this);
+        return CONTEXT_CURRENT_NEW;
       }
-    }
+      makeCurrentImpl();
+      return CONTEXT_CURRENT;
   }
   protected abstract void makeCurrentImpl() throws GLException;
   
   /** 
    * Platform dependent entry point for context creation.<br>
    *
-   * This method is called from {@link #makeCurrentLocking()} .. {@link #makeCurrent()} .<br>
+   * This method is called from {@link #makeCurrentWithinLock()} .. {@link #makeCurrent()} .<br>
    *
    * The implementation shall verify this context with a 
    * <code>MakeContextCurrent</code> call.<br>
diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
index 41b4ea878..509839f55 100644
--- a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
+++ b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
@@ -57,6 +57,9 @@ import com.jogamp.opengl.util.Animator;
     methods to be able to share it between GLCanvas and GLJPanel. */
 
 public class GLDrawableHelper {
+  /** true if property <code>jogl.debug.GLDrawable.PerfStats</code> is defined. */
+  private static final boolean PERF_STATS = Debug.isPropertyDefined("jogl.debug.GLDrawable.PerfStats", true);
+    
   protected static final boolean DEBUG = GLDrawableImpl.DEBUG;
   private Object listenersLock = new Object();
   private ArrayList<GLEventListener> listeners;
@@ -128,6 +131,10 @@ public class GLDrawableHelper {
   /**
    * Issues {@link javax.media.opengl.GLEventListener#dispose(javax.media.opengl.GLAutoDrawable)}
    * to all listeners.
+   * <p>
+   * Please consider using {@link #disposeGL(GLAutoDrawable, GLDrawable, GLContext, Runnable)}
+   * for correctness!
+   * </p>
    * @param drawable
    */
   public final void dispose(GLAutoDrawable drawable) {
@@ -137,7 +144,7 @@ public class GLDrawableHelper {
         }
     }
   }
-
+  
   private boolean init(GLEventListener l, GLAutoDrawable drawable, boolean sendReshape) {
       if(listenersToBeInit.remove(l)) {
           l.init(drawable);
@@ -307,6 +314,8 @@ public class GLDrawableHelper {
    *          ie. {@link Animator#getThread()}.
    * @deprecated this is an experimental feature, 
    *             intended for measuring performance in regards to GL context switch
+   *             and only being used if {@link #PERF_STATS} is enabled
+   *             by defining property <code>jogl.debug.GLDrawable.PerfStats</code>.
    */
   public final void setSkipContextReleaseThread(Thread t) {
     skipContextReleaseThread = t;
@@ -318,7 +327,7 @@ public class GLDrawableHelper {
   public final Thread getSkipContextReleaseThread() {
     return skipContextReleaseThread;
   }
-
+  
   private static final ThreadLocal<Runnable> perThreadInitAction = new ThreadLocal<Runnable>();
 
   /** Principal helper method which runs a Runnable with the context
@@ -328,8 +337,6 @@ public class GLDrawableHelper {
       class helps ensure that we don't inadvertently use private
       methods of the GLContext or its implementing classes.<br>
    * <br>
-   * Remark: In case this method is called to dispose the GLDrawable/GLAutoDrawable,
-   * <code>initAction</code> shall be <code>null</code> to mark this cause.<br>
    *
    * @param drawable
    * @param context
@@ -348,12 +355,112 @@ public class GLDrawableHelper {
         return;
     }
 
-    final boolean isDisposeAction = null==initAction ;
-    
-    if( isDisposeAction && !context.isCreated() ) {
-        throw new GLException(Thread.currentThread().getName()+" GLDrawableHelper " + this + ".invokeGL(): Dispose case (no init action given): Native context is not created: "+context);
+    if(PERF_STATS) {
+        invokeGLImplStats(drawable, context, runnable, initAction, null);    
+    } else {
+        invokeGLImpl(drawable, context, runnable, initAction, null);
     }
+  }
 
+  /** 
+   * Principal helper method which runs {@link #dispose(GLAutoDrawable)} with the context
+   * made current and destroys the context afterwards while holding the lock.  
+   * 
+   * @param autoDrawable
+   * @param drawable
+   * @param context
+   * @param postAction
+   */
+  public final void disposeGL(GLAutoDrawable autoDrawable,
+                              GLDrawable drawable,
+                              GLContext context,
+                              Runnable  postAction) {
+    if(PERF_STATS) {
+        invokeGLImplStats(drawable, context, null, null, autoDrawable);    
+    } else {
+        invokeGLImpl(drawable, context, null, null, autoDrawable);
+    }
+    if(null != postAction) {
+        postAction.run();
+    }
+  }
+  
+  private final void invokeGLImpl(GLDrawable drawable,
+                                  GLContext context,
+                                  Runnable  runnable,
+                                  Runnable  initAction,
+                                  GLAutoDrawable disposeAutoDrawable) {
+    final Thread currentThread = Thread.currentThread();
+    
+    final boolean isDisposeAction = null==initAction ;
+        
+    // Support for recursive makeCurrent() calls as well as calling
+    // other drawables' display() methods from within another one's
+    GLContext lastContext = GLContext.getCurrent();
+    Runnable  lastInitAction = null;
+    if (lastContext != null) {
+        if (lastContext == context) {
+            lastContext = null; // utilize recursive locking
+        } else {
+            lastInitAction = perThreadInitAction.get();
+            lastContext.release();
+        }
+    }
+    int res = GLContext.CONTEXT_NOT_CURRENT;
+  
+    try {
+      res = context.makeCurrent();
+      if (res != GLContext.CONTEXT_NOT_CURRENT) {
+        if(!isDisposeAction) {
+            perThreadInitAction.set(initAction);
+            if (res == GLContext.CONTEXT_CURRENT_NEW) {
+              if (DEBUG) {
+                System.err.println("GLDrawableHelper " + this + ".invokeGL(): Running initAction");
+              }
+              initAction.run();
+            }
+            runnable.run();
+            if (autoSwapBufferMode) {
+                drawable.swapBuffers();
+            }
+        } else {
+            if(res == GLContext.CONTEXT_CURRENT_NEW) {
+                throw new GLException(currentThread.getName()+" GLDrawableHelper " + this + ".invokeGL(): Dispose case (no init action given): Native context was not created (new ctx): "+context);
+            }
+            if(listeners.size()>0) {
+                dispose(disposeAutoDrawable);
+            }
+        }
+      }
+    } finally {
+      try {
+          if(isDisposeAction) {
+              context.destroy();
+          } else if( res != GLContext.CONTEXT_NOT_CURRENT ) {
+              context.release();
+          }
+      } catch (Exception e) {
+          System.err.println("Catched: "+e.getMessage());
+          e.printStackTrace();
+      }
+      if (lastContext != null) {
+        final int res2 = lastContext.makeCurrent();
+        if (null != lastInitAction && res2 == GLContext.CONTEXT_CURRENT_NEW) {
+          lastInitAction.run();
+        }
+      }
+    }
+  }
+  
+  private final void invokeGLImplStats(GLDrawable drawable,
+                                       GLContext context,
+                                       Runnable  runnable,
+                                       Runnable  initAction,
+                                       GLAutoDrawable disposeAutoDrawable) {
+    final Thread currentThread = Thread.currentThread();
+    
+    final boolean isDisposeAction = null==initAction ;
+    
     // Support for recursive makeCurrent() calls as well as calling
     // other drawables' display() methods from within another one's
     int res = GLContext.CONTEXT_NOT_CURRENT;
@@ -361,7 +468,9 @@ public class GLDrawableHelper {
     Runnable  lastInitAction = null;
     if (lastContext != null) {
         if (lastContext == context) {
-            res = GLContext.CONTEXT_CURRENT;
+            if( currentThread == skipContextReleaseThread ) {
+                res = GLContext.CONTEXT_CURRENT;
+            } // else: utilize recursive locking
             lastContext = null;
         } else {
             lastInitAction = perThreadInitAction.get();
@@ -369,17 +478,18 @@ public class GLDrawableHelper {
         }
     }
   
-    /**
     long t0 = System.currentTimeMillis();
-    long td1 = 0; // makeCurrent
+    long tdA = 0; // makeCurrent
     long tdR = 0; // render time
-    long td2 = 0; // swapBuffers
-    long td3 = 0; // release
-    boolean scr = true; */
-    
+    long tdS = 0; // swapBuffers
+    long tdX = 0; // release
+    boolean ctxClaimed = false;
+    boolean ctxReleased = false;
+    boolean ctxDestroyed = false;    
     try {
       if (res == GLContext.CONTEXT_NOT_CURRENT) {
           res = context.makeCurrent();
+          ctxClaimed = true;
       }
       if (res != GLContext.CONTEXT_NOT_CURRENT) {
         if(!isDisposeAction) {
@@ -390,39 +500,50 @@ public class GLDrawableHelper {
               }
               initAction.run();
             }
-        }
-        // tdR = System.currentTimeMillis();        
-        // td1 = tdR - t0; // makeCurrent
-        if(null!=runnable) {
+            tdR = System.currentTimeMillis();        
+            tdA = tdR - t0; // makeCurrent
             runnable.run();
-            // td2 = System.currentTimeMillis();
-            // tdR = td2 - tdR; // render time
-            if (autoSwapBufferMode && !isDisposeAction && drawable != null) {
+            tdS = System.currentTimeMillis();
+            tdR = tdS - tdR; // render time
+            if (autoSwapBufferMode) {
                 drawable.swapBuffers();
-                // td3 = System.currentTimeMillis();
-                // td2 = td3 - td2; // swapBuffers
+                tdX = System.currentTimeMillis();
+                tdS = tdX - tdS; // swapBuffers
+            }
+        } else {
+            if(res == GLContext.CONTEXT_CURRENT_NEW) {
+                throw new GLException(currentThread.getName()+" GLDrawableHelper " + this + ".invokeGL(): Dispose case (no init action given): Native context was not created (new ctx): "+context);
+            }
+            if(listeners.size()>0) {
+                dispose(disposeAutoDrawable);
             }
         }
       }
     } finally {
-      if(res != GLContext.CONTEXT_NOT_CURRENT &&
-         (null == skipContextReleaseThread || Thread.currentThread()!=skipContextReleaseThread) ) {
-          try {
+      try {
+          if(isDisposeAction) {
+              context.destroy();
+              ctxDestroyed = true;
+          } else if( res != GLContext.CONTEXT_NOT_CURRENT &&
+                     (null == skipContextReleaseThread || currentThread != skipContextReleaseThread) ) {
               context.release();
-              // scr = false;
-          } catch (Exception e) {
+              ctxReleased = true;
           }
+      } catch (Exception e) {
+          System.err.println("Catched: "+e.getMessage());
+          e.printStackTrace();
       }
-      // td3 = System.currentTimeMillis() - td3; // release
+
+      tdX = System.currentTimeMillis() - tdX; // release / destroy
       if (lastContext != null) {
-        int res2 = lastContext.makeCurrent();
+        final int res2 = lastContext.makeCurrent();
         if (null != lastInitAction && res2 == GLContext.CONTEXT_CURRENT_NEW) {
           lastInitAction.run();
         }
       }
     }
-    // long td0 = System.currentTimeMillis() - t0;
-    // System.err.println("td0 "+td0+"ms, fps "+(1.0/(td0/1000.0))+", td-makeCurrent: "+td1+"ms, td-render "+tdR+"ms, td-swap "+td2+"ms, td-release "+td3+"ms, skip ctx release: "+scr);
+    long td = System.currentTimeMillis() - t0;
+    System.err.println("td0 "+td+"ms, fps "+(1.0/(td/1000.0))+", td-makeCurrent: "+tdA+"ms, td-render "+tdR+"ms, td-swap "+tdS+"ms, td-release "+tdX+"ms, ctx claimed: "+ctxClaimed+", ctx release: "+ctxReleased+", ctx destroyed "+ctxDestroyed);
   }
-
+    
 }
diff --git a/src/jogl/classes/jogamp/opengl/GLPbufferImpl.java b/src/jogl/classes/jogamp/opengl/GLPbufferImpl.java
index ae83965e9..10d5a3f27 100644
--- a/src/jogl/classes/jogamp/opengl/GLPbufferImpl.java
+++ b/src/jogl/classes/jogamp/opengl/GLPbufferImpl.java
@@ -99,28 +99,21 @@ public class GLPbufferImpl implements GLPbuffer {
     return true;
   }
 
-  class DisposeAction implements Runnable {
-    public void run() {
-        // Lock: Covered by DestroyAction ..
-        drawableHelper.dispose(GLPbufferImpl.this);
-    }
-  }
-  DisposeAction disposeAction = new DisposeAction();
-
   public void destroy() {
     if(pbufferDrawable.isRealized()) {
         final AbstractGraphicsDevice adevice = pbufferDrawable.getNativeSurface().getGraphicsConfiguration().getScreen().getDevice();
         
         if (null != context && context.isCreated()) {
             try {
-                drawableHelper.invokeGL(pbufferDrawable, context, disposeAction, null);
+                drawableHelper.disposeGL(GLPbufferImpl.this, pbufferDrawable, context, null);
             } catch (GLException gle) {
                 gle.printStackTrace();
             }
-            context.destroy();
+            context = null;
             // drawableHelper.reset();
         }
         pbufferDrawable.destroy();
+        pbufferDrawable = null;
         
         if(null != adevice) {
             adevice.close();
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java
index 1e55879f7..3dd7a7f08 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLDrawableFactory.java
@@ -234,7 +234,6 @@ public class MacOSXCGLDrawableFactory extends GLDrawableFactoryImpl {
                             gle.printStackTrace();
                         }
                     } finally {
-                        context.release();
                         context.destroy();
                     }
                 }
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXDrawableFactory.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXDrawableFactory.java
index 235aea499..acced638f 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXDrawableFactory.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXDrawableFactory.java
@@ -283,7 +283,6 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
 
             if (null != sr.context) {
                 // may cause JVM SIGSEGV:
-                sr.context.makeCurrent();
                 sr.context.destroy();
                 sr.context = null;
             }