Bug 773 - Device specific JOCL dynamic library look-up on Android - Part 1/2

Use DynamicLibraryBundleInfo w/ alternative native library names,
drop manual coding of loading and binding, i.e. JOCLJNILibLoader.

After trying opencl native libs (and failing), try GL libs ..

We use a manual impl. to CL's 'clGetExtensionFunctionAddress' similar to JOAL, JOGL ...

7 files changed, 257 insertions, 162 deletions

diff --git a/resources/cl-impl.cfg b/resources/cl-impl.cfg
index 32a3099d..c2aff892 100644
--- a/resources/cl-impl.cfg
+++ b/resources/cl-impl.cfg
@@ -5,6 +5,8 @@ Style ImplOnly
 #imports for all generated java files
 Import com.jogamp.opencl.llb.*
 Import com.jogamp.opencl.llb.gl.CLGL
+Import java.security.AccessController
+Import java.security.PrivilegedAction
 
 ClassJavadoc CLAbstractImpl /**
 ClassJavadoc CLAbstractImpl  * Java bindings to OpenCL, the Open Computing Language (generated).
@@ -45,10 +47,11 @@ ProcAddressNameExpr $UpperCase(arg)
 #...or force all
 ForceProcAddressGen __ALL__
 
-Unignore clGetExtensionFunctionAddress
-RenameJavaMethod clGetExtensionFunctionAddress clGetExtensionFunctionAddressImpl
-AccessControl clGetExtensionFunctionAddressImpl PROTECTED
-ArgumentIsString clGetExtensionFunctionAddressImpl 0
+#
+# extern CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * /* func_name */) CL_API_SUFFIX__VERSION_1_0;
+#
+Ignore clGetExtensionFunctionAddress
+ForceProcAddressGen clGetExtensionFunctionAddress
 
 #append to generated c files
 CustomCCode #include <CL/cl.h>
diff --git a/resources/clImplCustomCode.c b/resources/clImplCustomCode.c
index 4a43ae3b..751f819b 100644
--- a/resources/clImplCustomCode.c
+++ b/resources/clImplCustomCode.c
@@ -112,6 +112,30 @@ CL_CALLBACK void memObjDestructorCallback(cl_mem mem, void * object) {
     (*jvm)->DetachCurrentThread(jvm);
 }
 
+// extern CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * /* func_name */) CL_API_SUFFIX__VERSION_1_0;
+
+JNIEXPORT jlong JNICALL
+Java_com_jogamp_opencl_llb_impl_CLAbstractImpl_dispatch_1clGetExtensionFunctionAddressStatic(JNIEnv *env, jclass _unused, jstring fname, jlong procAddress) {
+  typedef void* (CL_API_ENTRY*_local_LPCLGETPROCADDRESS)(const char *  fname);
+  _local_LPCLGETPROCADDRESS ptr_clGetExtensionFunctionAddress;
+  const char* _strchars_fname = NULL;
+  void* _res;
+  if ( NULL != fname ) {
+    _strchars_fname = (*env)->GetStringUTFChars(env, fname, (jboolean*)NULL);
+  if ( NULL == _strchars_fname ) {
+      (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/OutOfMemoryError"),
+                       "Failed to get UTF-8 chars for argument \"fname\" in native dispatcher for \"dispatch_clGetExtensionFunctionAddress\"");
+      return 0;
+    }
+  }
+  ptr_clGetExtensionFunctionAddress = (_local_LPCLGETPROCADDRESS) (intptr_t) procAddress;
+  assert(ptr_clGetExtensionFunctionAddress != NULL);
+  _res = (* ptr_clGetExtensionFunctionAddress) ((char *) _strchars_fname);
+  if ( NULL != fname ) {
+    (*env)->ReleaseStringUTFChars(env, fname, _strchars_fname);
+  }
+  return (jlong) (intptr_t) _res;
+}
 
 /*   Java->C glue code:
  *   Java package: com.jogamp.opencl.impl.CLImpl
diff --git a/resources/clImplCustomCode.java b/resources/clImplCustomCode.java
index 1826da86..bee53425 100644
--- a/resources/clImplCustomCode.java
+++ b/resources/clImplCustomCode.java
@@ -1,6 +1,53 @@
 
-    protected final CLProcAddressTable addressTable;
+    static final DynamicLibraryBundle dynamicLookupHelper;
+    protected static final CLProcAddressTable addressTable;
 
-    public CLAbstractImpl(CLProcAddressTable addressTable) {
-        this.addressTable = addressTable;
+    static {
+      addressTable = new CLProcAddressTable();
+      if(null==addressTable) {
+        throw new RuntimeException("Couldn't instantiate ALProcAddressTable");
+      }
+  
+      dynamicLookupHelper = AccessController.doPrivileged(new PrivilegedAction<DynamicLibraryBundle>() {
+                                  public DynamicLibraryBundle run() {
+                                      final DynamicLibraryBundle bundle =  new DynamicLibraryBundle(new CLDynamicLibraryBundleInfo());
+                                      if(null==bundle) {
+                                        throw new RuntimeException("Null CLDynamicLookupHelper");
+                                      }
+                                      if(!bundle.isToolLibLoaded()) {
+                                        throw new RuntimeException("Couln't load native CL library");
+                                      }
+                                      if(!bundle.isLibComplete()) {
+                                        throw new RuntimeException("Couln't load native CL/JNI glue library");
+                                      }
+                                      addressTable.reset(bundle);
+                                      return bundle;
+                                  } } );
     }
+
+    public static CLProcAddressTable getCLProcAddressTable() { return addressTable; }
+
+    static long clGetExtensionFunctionAddress(long clGetExtensionFunctionAddressHandle, java.lang.String procname)
+    {
+        if (clGetExtensionFunctionAddressHandle == 0) {
+            throw new RuntimeException("Passed null pointer for method \"clGetExtensionFunctionAddress\"");
+        }
+        return dispatch_clGetExtensionFunctionAddressStatic(procname, clGetExtensionFunctionAddressHandle);
+    }
+
+    public CLAbstractImpl() {
+    }
+
+    /** Entry point (through function pointer) to C language function: <br> <code> void* clGetExtensionFunctionAddress(const char *  fname); </code>    */
+    long clGetExtensionFunctionAddress(String fname)  {
+
+        final long __addr_ = addressTable._addressof_clGetExtensionFunctionAddress;
+        if (__addr_ == 0) {
+            throw new UnsupportedOperationException("Method \"clGetExtensionFunctionAddress\" not available");
+        }
+        return dispatch_clGetExtensionFunctionAddressStatic(fname, __addr_);
+    }
+
+    /** Entry point (through function pointer) to C language function: <br> <code> void* clGetExtensionFunctionAddress(const char *  fname); </code>    */
+    private static native long dispatch_clGetExtensionFunctionAddressStatic(String fname, long procAddress);
+
diff --git a/src/com/jogamp/opencl/CLPlatform.java b/src/com/jogamp/opencl/CLPlatform.java
index 7a4f6b43..99b2e16d 100644
--- a/src/com/jogamp/opencl/CLPlatform.java
+++ b/src/com/jogamp/opencl/CLPlatform.java
@@ -3,14 +3,14 @@
  *
  * 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
@@ -20,7 +20,7 @@
  * 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.
@@ -36,11 +36,8 @@ import com.jogamp.opencl.llb.CLImageBinding;
 import com.jogamp.opencl.llb.CL;
 import com.jogamp.opencl.impl.CLTLAccessorFactory;
 import com.jogamp.common.nio.Buffers;
-import com.jogamp.common.os.DynamicLookupHelper;
 import com.jogamp.common.JogampRuntimeException;
-import com.jogamp.common.os.NativeLibrary;
 import com.jogamp.common.nio.PointerBuffer;
-import com.jogamp.gluegen.runtime.FunctionAddressResolver;
 import com.jogamp.opencl.llb.CLBufferBinding;
 import com.jogamp.opencl.llb.CLCommandQueueBinding;
 import com.jogamp.opencl.llb.CLContextBinding;
@@ -50,7 +47,6 @@ import com.jogamp.opencl.llb.CLMemObjBinding;
 import com.jogamp.opencl.spi.CLPlatformInfoAccessor;
 import com.jogamp.opencl.util.CLUtil;
 import com.jogamp.opencl.llb.impl.CLImpl;
-import com.jogamp.opencl.llb.impl.CLProcAddressTable;
 import com.jogamp.opencl.spi.CLAccessorFactory;
 import com.jogamp.opencl.util.Filter;
 import com.jogamp.opencl.util.JOCLVersion;
@@ -63,15 +59,13 @@ import java.util.List;
 import java.util.Map;
 import java.util.Scanner;
 import java.util.Set;
-import java.security.PrivilegedAction;
 
-import static java.security.AccessController.*;
 import static com.jogamp.opencl.CLException.*;
 import static com.jogamp.opencl.llb.CL.*;
 
 /**
  * CLPlatfrorm representing a OpenCL implementation (e.g. graphics driver).
- * 
+ *
  * optional eager initialization:
  * <p><pre>
  *     try{
@@ -80,15 +74,15 @@ import static com.jogamp.opencl.llb.CL.*;
  *          throw new RuntimeException("could not load Java OpenCL Binding");
  *     }
  * </pre></p>
- * 
+ *
  * Example initialization:
  * <p><pre>
  *     CLPlatform platform = CLPlatform.getDefault(type(GPU));
- *      
+ *
  *     if(platform == null) {
  *          throw new RuntimeException("please update your graphics drivers");
  *     }
- * 
+ *
  *     CLContext context = CLContext.create(platform.getMaxFlopsDevice());
  *     try {
  *          // use it
@@ -98,7 +92,7 @@ import static com.jogamp.opencl.llb.CL.*;
  * </pre></p>
  * concurrency:<br/>
  * CLPlatform is threadsafe.
- * 
+ *
  * @author Michael Bien, et al.
  * @see #initialize()
  * @see #getDefault()
@@ -159,7 +153,7 @@ public class CLPlatform {
         if(cl != null) {
             return;
         }
-        
+
         if(defaultFactory == null) {
             if(factory == null) {
                 defaultFactory = new CLTLAccessorFactory();
@@ -169,49 +163,10 @@ public class CLPlatform {
         }
 
         try {
-
-            final CLProcAddressTable table = new CLProcAddressTable(new FunctionAddressResolver() {
-                @Override
-                public long resolve(String name, DynamicLookupHelper lookup) {
-
-                    //FIXME workaround to fix a gluegen issue
-                    if(name.endsWith("Impl")) {
-                        name = name.substring(0, name.length() - "Impl".length());
-                    }
-
-                    if(name.endsWith("KHR") || name.endsWith("EXT")) {
-                        long address = ((CLImpl) cl).clGetExtensionFunctionAddress(name);
-                        if(address != 0) {
-                            return address;
-                        }
-                    }
-
-                    return lookup.dynamicLookupFunction(name);
-                }
-            });
-
-            cl = new CLImpl(table);
-
-            //load JOCL and init table
-            doPrivileged(new PrivilegedAction<Object>() {
-                @Override
-                public Object run() {
-
-                    NativeLibrary libOpenCL = JOCLJNILibLoader.loadOpenCL();
-                    if(libOpenCL == null) {
-                        throw new JogampRuntimeException("OpenCL library not found.");
-                    }
-
-                    //eagerly init function to query extension addresses (used in reset())
-                    table.initEntry("clGetExtensionFunctionAddressImpl", libOpenCL);
-                    table.reset(libOpenCL);
-                    return null;
-                }
-            });
-
-//            System.out.println("\n"+table);
-//            System.out.println("unavailable functions: "+table.getNullPointerFunctions());
-
+            if( null == CLImpl.getCLProcAddressTable() ) {
+                throw new JogampRuntimeException("JOCL ProcAddressTable is NULL");
+            }
+            cl = new CLImpl();
         }catch(UnsatisfiedLinkError ex) {
             System.err.println(JOCLVersion.getAllVersions());
             throw ex;
@@ -321,7 +276,7 @@ public class CLPlatform {
         initialize();
 
         List<CLDevice> list = new ArrayList<CLDevice>();
-        
+
         for(int t = 0; t < types.length; t++) {
             CLDevice.Type type = types[t];
 
@@ -344,7 +299,7 @@ public class CLPlatform {
         initialize();
 
         List<CLDevice> list = new ArrayList<CLDevice>();
-        
+
         long[] deviceIDs = info.getDeviceIDs(CL_DEVICE_TYPE_ALL);
 
         //add device to list
@@ -381,7 +336,7 @@ public class CLPlatform {
     static CLDevice findMaxFlopsDevice(CLDevice[] devices) {
         return findMaxFlopsDevice(devices, null);
     }
-    
+
     static CLDevice findMaxFlopsDevice(CLDevice[] devices, CLDevice.Type type) {
         initialize();
 
@@ -470,7 +425,7 @@ public class CLPlatform {
     }
 
     /**
-     * @see CLVersion#isAtLeast(int, int) 
+     * @see CLVersion#isAtLeast(int, int)
      */
     public boolean isAtLeast(int major, int minor) {
         return version.isAtLeast(major, minor);
diff --git a/src/com/jogamp/opencl/JOCLJNILibLoader.java b/src/com/jogamp/opencl/JOCLJNILibLoader.java
deleted file mode 100644
index 83ca22d6..00000000
--- a/src/com/jogamp/opencl/JOCLJNILibLoader.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2009 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.opencl;
-
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-
-import com.jogamp.common.jvm.JNILibLoaderBase;
-import com.jogamp.common.os.NativeLibrary;
-import com.jogamp.common.os.Platform;
-import com.jogamp.common.util.cache.TempJarCache;
-
-
-/**
- * Responsible for JOCL lib loading.
- * @author Michael Bien
- */
-class JOCLJNILibLoader extends JNILibLoaderBase {
-
-    /**
-     * Loads the native binding and returns the OpenCL library for dynamic linking.
-     * @return Returns libOpenCL represented as NativeLibrary.
-     */
-    static NativeLibrary loadOpenCL() {
-        return AccessController.doPrivileged(new PrivilegedAction<NativeLibrary>() {
-          public NativeLibrary run() {
-            Platform.initSingleton();
-            
-            // Implementation should move to com.jogamp.common.os.DynamicLibraryBundleInfo, 
-            // eg.: jogamp.opengl.GLDynamicLibraryBundleInfo etc.
-            final String libName = "jocl";
-            if(TempJarCache.isInitialized() && null == TempJarCache.findLibrary(libName)) {
-                // only: jocl.jar -> jocl-natives-<os.and.arch>.jar
-                addNativeJarLibs(new Class<?>[] { JOCLJNILibLoader.class }, null, null );
-            }
-            loadLibrary(libName, false, JOCLJNILibLoader.class.getClassLoader());
-            NativeLibrary res = NativeLibrary.open("OpenCL", JOCLJNILibLoader.class.getClassLoader());
-            if(null == res) {
-                // try unix name w/ version (eg.: AMD has a /usr/lib32/fglrx/libOpenCL.so.1 only)
-                res = NativeLibrary.open("libOpenCL.so.1", JOCLJNILibLoader.class.getClassLoader());
-            }
-            return res;
-          }
-        });
-    }
-}
diff --git a/src/com/jogamp/opencl/llb/impl/CLDynamicLibraryBundleInfo.java b/src/com/jogamp/opencl/llb/impl/CLDynamicLibraryBundleInfo.java
new file mode 100644
index 00000000..ff5a122a
--- /dev/null
+++ b/src/com/jogamp/opencl/llb/impl/CLDynamicLibraryBundleInfo.java
@@ -0,0 +1,152 @@
+/**
+ * Copyright 2013 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.opencl.llb.impl;
+
+import com.jogamp.common.jvm.JNILibLoaderBase;
+import com.jogamp.common.os.DynamicLibraryBundle;
+import com.jogamp.common.os.DynamicLibraryBundleInfo;
+import com.jogamp.common.os.Platform;
+import com.jogamp.common.util.RunnableExecutor;
+import com.jogamp.common.util.cache.TempJarCache;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.*;
+
+public final class CLDynamicLibraryBundleInfo implements DynamicLibraryBundleInfo  {
+    private static final List<String> glueLibNames;
+    static {
+        AccessController.doPrivileged(new PrivilegedAction<Object>() {
+            public Object run() {
+                Platform.initSingleton();
+
+                if( TempJarCache.isInitialized() ) {
+                   // only: jocl.jar -> jocl-natives-<os.and.arch>.jar
+                   JNILibLoaderBase.addNativeJarLibs(new Class<?>[] { CLDynamicLibraryBundleInfo.class }, null, null );
+                }
+                return null;
+            }
+        });
+
+        glueLibNames = new ArrayList<String>();
+        glueLibNames.add("jocl");
+    }
+
+    protected CLDynamicLibraryBundleInfo() {
+    }
+
+    /**
+     * <p>
+     * Returns <code>true</code>,
+     * since we might load the library and allow symbol access to subsequent libs.
+     * </p>
+     */
+    @Override
+    public final boolean shallLinkGlobal() { return true; }
+
+    /**
+     * {@inheritDoc}
+     * Returns <code>true</code> on <code>Android</code>,
+     * and <code>false</code> otherwise.
+     */
+    @Override
+    public final boolean shallLookupGlobal() {
+        if ( Platform.OSType.ANDROID == Platform.OS_TYPE ) {
+            // Android requires global symbol lookup
+            return true;
+        }
+        // default behavior for other platforms
+        return false;
+    }
+
+    @Override
+    public final List<String> getGlueLibNames() {
+        return glueLibNames;
+    }
+
+    @Override
+    public final List<List<String>> getToolLibNames() {
+        List<List<String>> libNamesList = new ArrayList<List<String>>();
+
+        final List<String> libCL = new ArrayList<String>();
+        {
+            // this is the default OpenCL lib name, according to the spec
+            libCL.add("libOpenCL.so.1"); // unix
+            libCL.add("OpenCL"); // windows, OSX
+
+            // try this one as well, if spec fails
+            libCL.add("libGL.so.1");
+
+            // ES2: This is the default lib name, according to the spec
+            libCL.add("libGLESv2.so.2");
+
+            // ES2: Try these as well, if spec fails
+            libCL.add("libGLESv2.so");
+            libCL.add("GLESv2");
+
+        }
+        libNamesList.add(libCL);
+
+        return libNamesList;
+    }
+
+    @Override
+    public final List<String> getToolGetProcAddressFuncNameList() {
+        List<String> res = new ArrayList<String>();
+        res.add("clGetExtensionFunctionAddress");
+        return res;
+    }
+
+    private static String Impl_str = "Impl";
+    private static int Impl_len = Impl_str.length();
+
+    @Override
+    public final long toolGetProcAddress(long toolGetProcAddressHandle, String funcName) {
+        //FIXME workaround to fix a gluegen issue
+        if( funcName.endsWith(Impl_str) ) {
+            funcName = funcName.substring(0, funcName.length() - Impl_len);
+        }
+        if(funcName.endsWith("KHR") || funcName.endsWith("EXT")) {
+            return CLImpl.clGetExtensionFunctionAddress(toolGetProcAddressHandle, funcName);
+        }
+        return 0; // on libs ..
+    }
+
+    @Override
+    public final boolean useToolGetProcAdressFirst(String funcName) {
+        return true;
+    }
+
+    @Override
+    public final RunnableExecutor getLibLoaderExecutor() {
+        return DynamicLibraryBundle.getDefaultRunnableExecutor();
+    }
+}
+
+
diff --git a/src/com/jogamp/opencl/llb/impl/CLImpl.java b/src/com/jogamp/opencl/llb/impl/CLImpl.java
index 253e19e6..ad89ff9f 100644
--- a/src/com/jogamp/opencl/llb/impl/CLImpl.java
+++ b/src/com/jogamp/opencl/llb/impl/CLImpl.java
@@ -3,14 +3,14 @@
  *
  * 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
@@ -20,7 +20,7 @@
  * 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.
@@ -50,8 +50,8 @@ public class CLImpl extends CLAbstractImpl {
     //maps the context id to its error handler's global object pointer
     private final LongLongHashMap contextCallbackMap;
 
-    public CLImpl(CLProcAddressTable addressTable) {
-        super(addressTable);
+    public CLImpl() {
+        super();
         this.contextCallbackMap = new LongLongHashMap();
         this.contextCallbackMap.setKeyNotFoundValue(0);
     }
@@ -253,20 +253,6 @@ public class CLImpl extends CLAbstractImpl {
             int num_events_in_wait_list, Object event_wait_list, int event_wait_list_byte_offset, Object event,
             int event_byte_offset, Object errcode_ret, int errcode_ret_byte_offset);
 
-    /**
-     * Returns the extension function address for the given function name.
-     */
-    public long clGetExtensionFunctionAddress(String name) {
-        ByteBuffer res = super.clGetExtensionFunctionAddressImpl(name);
-        if(res == null) {
-            return 0;
-        }else if (Platform.is32Bit()) {
-            return res.getInt();
-        } else {
-            return res.getLong();
-        }
-    }
-
     public CLProcAddressTable getAddressTable() {
         return addressTable;
     }