Workaround (Fix) for Bug 502: Multithreading issue w/ libX11 1.4.2 and libxcb 1.7 bug 20708

See https://jogamp.org/bugzilla/show_bug.cgi?id=502

Since the libX11/xcb code doesn't seem to be fixed anytime soon
a better usable workaround is required than using a system property
to enable 'over locking'.

It turns out that the race condition is related to the parallel
X11 Display connection usage of GLX/OpenGL and event dispatching.
This workaround utilizes 2 X11 Display handles, one for windowing/OpenGL
and one for event dispatching.
This approach allows us to cont. multithreading use w/o locking the display
and works on both implementations, the old bug-free libX11 and the 'new' buggy one.

Downside is the little resource overhead of the 2nd X11 Display connection .. well.

- Removes the property: 'nativewindow.x11.mt-bug'

4 files changed, 69 insertions, 44 deletions

diff --git a/src/nativewindow/classes/jogamp/nativewindow/x11/X11Util.java b/src/nativewindow/classes/jogamp/nativewindow/x11/X11Util.java
index 117184a71..37056d44d 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/x11/X11Util.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/x11/X11Util.java
@@ -51,15 +51,6 @@ import javax.media.nativewindow.util.Point;
  * Contains a thread safe X11 utility to retrieve display connections.
  */
 public class X11Util {
-    /**
-     * 2011/06/14 libX11 1.4.2 and libxcb 1.7 bug 20708 - Multithreading Issues w/ OpenGL, ..
-     *            https://bugs.freedesktop.org/show_bug.cgi?id=20708
-     *            https://jogamp.org/bugzilla/show_bug.cgi?id=502
-     *            Affects: Ubuntu 11.04, OpenSuSE 11, ..
-     * If the property <b>nativewindow.x11.mt-bug</b> is set to true, extensive X11 locking 
-     * is being applied, avoiding X11 multithreading capabilities. 
-     */
-    public static final boolean MULTITHREADING_BUG = Debug.getBooleanProperty("nativewindow.x11.mt-bug", true, AccessController.getContext());
     public static final boolean XINITTHREADS_ALWAYS_ENABLED = true;
 
     private static final boolean DEBUG = Debug.debug("X11Util");
@@ -84,12 +75,11 @@ public class X11Util {
              */
             initialize0( XINITTHREADS_ALWAYS_ENABLED ? true : firstX11ActionOnProcess );
 
-            requiresX11Lock = !firstX11ActionOnProcess || MULTITHREADING_BUG;
+            requiresX11Lock = !firstX11ActionOnProcess ;
             
             if(DEBUG) {
                 System.out.println("X11Util firstX11ActionOnProcess: "+firstX11ActionOnProcess+
                                    ", XINITTHREADS_ALWAYS_ENABLED "+XINITTHREADS_ALWAYS_ENABLED+
-                                   ", MULTITHREADING_BUG "+MULTITHREADING_BUG+
                                    ", requiresX11Lock "+requiresX11Lock); 
             }
             isInit = true;
@@ -160,8 +150,8 @@ public class X11Util {
     // which is to tag a NamedDisplay uncloseable after creation.
     private static Object globalLock = new Object(); 
     private static LongObjectHashMap globalNamedDisplayMap = new LongObjectHashMap();
-    private static List openDisplayList = new ArrayList();
-    private static List pendingDisplayList = new ArrayList();
+    private static List<NamedDisplay> openDisplayList = new ArrayList<NamedDisplay>();
+    private static List<NamedDisplay> pendingDisplayList = new ArrayList<NamedDisplay>();
 
     public static class NamedDisplay {
         String name;
@@ -269,7 +259,7 @@ public class X11Util {
         synchronized(globalLock) {
             System.err.println("X11Util: Open X11 Display Connections: "+openDisplayList.size());
             for(int i=0; i<pendingDisplayList.size(); i++) {
-                NamedDisplay ndpy = (NamedDisplay) openDisplayList.get(i);
+                NamedDisplay ndpy = openDisplayList.get(i);
                 System.err.println("X11Util: ["+i+"]: "+ndpy);
                 if(null!=ndpy) {
                     Throwable t = ndpy.getCreationStack();
diff --git a/src/newt/classes/jogamp/newt/driver/x11/X11Display.java b/src/newt/classes/jogamp/newt/driver/x11/X11Display.java
index 483556f82..94e5a0bcc 100644
--- a/src/newt/classes/jogamp/newt/driver/x11/X11Display.java
+++ b/src/newt/classes/jogamp/newt/driver/x11/X11Display.java
@@ -69,14 +69,23 @@ public class X11Display extends DisplayImpl {
         if( 0 == handle ) {
             throw new RuntimeException("Error creating display: "+name);
         }
+        if(USE_SEPARATE_DISPLAY_FOR_EDT) {
+            edtDisplayHandle = X11Util.createDisplay(name);
+            if( 0 == edtDisplayHandle ) {
+                X11Util.closeDisplay(handle);
+                throw new RuntimeException("Error creating display(EDT): "+name);
+            }
+        } else {
+            edtDisplayHandle = handle;
+        }
         try {
-            CompleteDisplay0(handle);
+            CompleteDisplay0(edtDisplayHandle);
         } catch(RuntimeException e) {
-            X11Util.closeDisplay(handle);
+            closeNativeImpl();
             throw e;
         }
         
-        if(X11Util.XINITTHREADS_ALWAYS_ENABLED && !X11Util.MULTITHREADING_BUG) {
+        if(X11Util.XINITTHREADS_ALWAYS_ENABLED) {
             // Hack: Force non X11Display locking, even w/ AWT and w/o isFirstUIActionOnProcess() 
             aDevice = new X11GraphicsDevice(handle, AbstractGraphicsDevice.DEFAULT_UNIT, NativeWindowFactory.getNullToolkitLock());            
         } else {
@@ -86,25 +95,29 @@ public class X11Display extends DisplayImpl {
     }
 
     protected void closeNativeImpl() {
-        X11Util.closeDisplay(getHandle());
+        final long handle = getHandle();
+        if(handle != edtDisplayHandle) {
+            X11Util.closeDisplay(edtDisplayHandle);
+        }
+        X11Util.closeDisplay(handle);
     }
 
     protected void dispatchMessagesNative() {
-        long dpy = getHandle();
-        if(0!=dpy) {
-            DispatchMessages0(dpy, javaObjectAtom, windowDeleteAtom);
+        if(0 != edtDisplayHandle) {
+            DispatchMessages0(edtDisplayHandle, javaObjectAtom, windowDeleteAtom);
         }
     }
 
+    protected long getEDTHandle() { return edtDisplayHandle; }
     protected long getJavaObjectAtom() { return javaObjectAtom; }
     protected long getWindowDeleteAtom() { return windowDeleteAtom; }
-
+    
     //----------------------------------------------------------------------
     // Internals only
     //
     private static native boolean initIDs0();
 
-    private native void CompleteDisplay0(long handle);
+    private native void CompleteDisplay0(long handleEDT);
 
     private native void DispatchMessages0(long display, long javaObjectAtom, long windowDeleteAtom);
 
@@ -113,7 +126,21 @@ public class X11Display extends DisplayImpl {
         this.windowDeleteAtom=windowDeleteAtom;
     }
 
+    /**
+     * 2011/06/14 libX11 1.4.2 and libxcb 1.7 bug 20708 - Multithreading Issues w/ OpenGL, ..
+     *            https://bugs.freedesktop.org/show_bug.cgi?id=20708
+     *            https://jogamp.org/bugzilla/show_bug.cgi?id=502
+     *            Affects: Ubuntu 11.04, OpenSuSE 11, ..
+     *            Workaround: Using a separate X11 Display connection for event dispatching (EDT)
+     */    
+    private final boolean USE_SEPARATE_DISPLAY_FOR_EDT = true;
+    
+    private long edtDisplayHandle;
+    
+    /** X11 Window delete atom marker used on EDT */
     private long windowDeleteAtom;
+    
+    /** X11 Window java object property used on EDT */
     private long javaObjectAtom;
 }
 
diff --git a/src/newt/classes/jogamp/newt/driver/x11/X11Window.java b/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
index 19a0c7626..cbb43934b 100644
--- a/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
+++ b/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
@@ -64,7 +64,7 @@ public class X11Window extends WindowImpl {
         X11GraphicsConfiguration x11config = (X11GraphicsConfiguration) config;
         long visualID = x11config.getVisualID();
         long w = CreateWindow0(getParentWindowHandle(),
-                               display.getHandle(), screen.getIndex(), visualID, 
+                               display.getHandle(), display.getEDTHandle(), screen.getIndex(), visualID, 
                                display.getJavaObjectAtom(), display.getWindowDeleteAtom(), 
                                x, y, width, height, isUndecorated());
         if (w == 0) {
@@ -78,7 +78,7 @@ public class X11Window extends WindowImpl {
         if(0!=windowHandleClose && null!=getScreen() ) {
             X11Display display = (X11Display) getScreen().getDisplay();
             try {
-                CloseWindow0(display.getHandle(), windowHandleClose, 
+                CloseWindow0(display.getHandle(), display.getEDTHandle(), windowHandleClose, 
                              display.getJavaObjectAtom(), display.getWindowDeleteAtom());
             } catch (Throwable t) {
                 if(DEBUG_IMPLEMENTATION) { 
@@ -124,10 +124,10 @@ public class X11Window extends WindowImpl {
     //
 
     protected static native boolean initIDs0();
-    private native long CreateWindow0(long parentWindowHandle, long display, int screen_index, 
+    private native long CreateWindow0(long parentWindowHandle, long display, long displayEDT, int screen_index, 
                                             long visualID, long javaObjectAtom, long windowDeleteAtom, 
                                             int x, int y, int width, int height, boolean undecorated);
-    private native void CloseWindow0(long display, long windowHandle, long javaObjectAtom, long windowDeleteAtom);
+    private native void CloseWindow0(long display, long displayEDT, long windowHandle, long javaObjectAtom, long windowDeleteAtom);
     private native void setVisible0(long display, long windowHandle, boolean visible, int x, int y, int width, int height);
     private native void reconfigureWindow0(long display, int screen_index, long parentWindowHandle, long windowHandle, 
                                                   int x, int y, int width, int height, boolean isVisible,
diff --git a/src/newt/native/X11Window.c b/src/newt/native/X11Window.c
index e0efac6e5..fc949b318 100644
--- a/src/newt/native/X11Window.c
+++ b/src/newt/native/X11Window.c
@@ -301,7 +301,7 @@ JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_CompleteDisplay0
         NewtCommon_FatalError(env, "invalid display connection..");
     }
 
-    javaObjectAtom = (jlong) XInternAtom(dpy, "JOGL_JAVA_OBJECT", False);
+    javaObjectAtom = (jlong) XInternAtom(dpy, "NEWT_JAVA_OBJECT", False);
     if(None==javaObjectAtom) {
         NewtCommon_throwNewRuntimeException(env, "could not create Atom JOGL_JAVA_OBJECT, bail out!");
         return;
@@ -559,7 +559,7 @@ JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_DispatchMessages0
             return ;
         }
 
-        // DBG_PRINT( "X11: DispatchMessages dpy %p, win %p, Event %d\n", (void*)dpy, (void*)evt.xany.window, evt.type);
+        DBG_PRINT( "X11: DispatchMessages dpy %p, win %p, Event %d\n", (void*)dpy, (void*)evt.xany.window, evt.type);
 
         displayDispatchErrorHandlerEnable(1, env);
 
@@ -1270,13 +1270,15 @@ JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Window_initIDs0
  * Signature: (JJIJIIII)J
  */
 JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
-  (JNIEnv *env, jobject obj, jlong parent, jlong display, jint screen_index, 
+  (JNIEnv *env, jobject obj, jlong parent, jlong display, jlong displayEDT, jint screen_index, 
                              jlong visualID, 
                              jlong javaObjectAtom, jlong windowDeleteAtom, 
                              jint x, jint y, jint width, jint height,
                              jboolean undecorated)
 {
     Display * dpy  = (Display *)(intptr_t)display;
+    Display * dpyEDT = (Display *)(intptr_t)displayEDT;
+    Atom wm_delete_atom = (Atom)windowDeleteAtom;
     int       scrn_idx = (int)screen_index;
     Window  windowParent = (Window) parent;
     Window  window = 0;
@@ -1291,7 +1293,6 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
     int n;
 
     Screen* scrn;
-    Atom wm_delete_atom;
 
     if(dpy==NULL) {
         NewtCommon_FatalError(env, "invalid display connection..");
@@ -1342,7 +1343,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
     }
 
     attrMask  = ( CWBackingStore | CWBackingPlanes | CWBackingPixel | CWBackPixmap |
-                  CWBorderPixel | CWColormap | CWOverrideRedirect | CWEventMask ) ;
+                  CWBorderPixel | CWColormap | CWOverrideRedirect /* | CWEventMask */ ) ;
 
     memset(&xswa, 0, sizeof(xswa));
     xswa.override_redirect = False; // use the window manager, always
@@ -1351,9 +1352,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
     xswa.backing_store=NotUseful; /* NotUseful, WhenMapped, Always */
     xswa.backing_planes=0;        /* planes to be preserved if possible */
     xswa.backing_pixel=0;         /* value to use in restoring planes */
-    xswa.event_mask  = ButtonPressMask | ButtonReleaseMask | PointerMotionMask ;
-    xswa.event_mask |= KeyPressMask | KeyReleaseMask ;
-    xswa.event_mask |= FocusChangeMask | SubstructureNotifyMask | StructureNotifyMask | ExposureMask ;
+    xswa.event_mask = 0;          /* using XSelectInput on EDT below */
 
     xswa.colormap = XCreateColormap(dpy,
                                     windowParent,
@@ -1376,14 +1375,22 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
         return 0;
     }
 
-    wm_delete_atom = (Atom)windowDeleteAtom;
-    XSetWMProtocols(dpy, window, &wm_delete_atom, 1);
-
-    setJavaWindowProperty(env, dpy, window, javaObjectAtom, (*env)->NewGlobalRef(env, obj));
-
     NewtWindows_setDecorations(dpy, window, ( JNI_TRUE == undecorated ) ? False : True );
     XSync(dpy, False);
 
+    XSetWMProtocols(dpyEDT, window, &wm_delete_atom, 1);
+    setJavaWindowProperty(env, dpyEDT, window, javaObjectAtom, (*env)->NewGlobalRef(env, obj));
+
+    {
+        long xevent_mask = 0;
+        xevent_mask |= ButtonPressMask | ButtonReleaseMask | PointerMotionMask ;
+        xevent_mask |= KeyPressMask | KeyReleaseMask ;
+        xevent_mask |= FocusChangeMask | SubstructureNotifyMask | StructureNotifyMask | ExposureMask ;
+
+        XSelectInput(dpyEDT, window, xevent_mask);
+    }
+    XSync(dpyEDT, False);
+
     DBG_PRINT( "X11: [CreateWindow] created window %p on display %p\n", (void*)window, dpy);
     return (jlong) window;
 }
@@ -1394,9 +1401,10 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
  * Signature: (JJ)V
  */
 JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Window_CloseWindow0
-  (JNIEnv *env, jobject obj, jlong display, jlong window, jlong javaObjectAtom, jlong wmDeleteAtom)
+  (JNIEnv *env, jobject obj, jlong display, jlong displayEDT, jlong window, jlong javaObjectAtom, jlong wmDeleteAtom)
 {
     Display * dpy = (Display *) (intptr_t) display;
+    Display * dpyEDT = (Display *) (intptr_t) displayEDT;
     Window w = (Window)window;
     jobject jwindow;
 
@@ -1406,7 +1414,7 @@ JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Window_CloseWindow0
 
     DBG_PRINT( "X11: CloseWindow START dpy %p, win %p\n", (void*)dpy, (void*)w);
 
-    jwindow = getJavaWindowProperty(env, dpy, w, javaObjectAtom, True);
+    jwindow = getJavaWindowProperty(env, dpyEDT, w, javaObjectAtom, True);
     if(NULL==jwindow) {
         NewtCommon_throwNewRuntimeException(env, "could not fetch Java Window object, bail out!");
         return;
@@ -1417,11 +1425,11 @@ JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Window_CloseWindow0
     }
 
     XSync(dpy, False);
-    XSelectInput(dpy, w, 0);
+    XSelectInput(dpyEDT, w, 0);
     XUnmapWindow(dpy, w);
 
     // Drain all events related to this window ..
-    Java_jogamp_newt_driver_x11_X11Display_DispatchMessages0(env, obj, display, javaObjectAtom, wmDeleteAtom);
+    Java_jogamp_newt_driver_x11_X11Display_DispatchMessages0(env, obj, displayEDT, javaObjectAtom, wmDeleteAtom);
 
     XDestroyWindow(dpy, w);
     XSync(dpy, False);