private static int getPlatformIDs( int count, Pointer<cl_platform_id> out, Pointer<Integer> pCount) { try { return CL.clIcdGetPlatformIDsKHR(count, out, pCount); } catch (Throwable th) { return CL.clGetPlatformIDs(count, out, pCount); } }
@Override public int compare(ClassRelationFull<CL> o1, ClassRelationFull<CL> o2) { CL o1Other = o1.getRelationship().getShapeRelationshipEnd().getShapeFull() == o1.getClassRelationship().getShapeFull() ? o1.getRelationship().getShapeRelationshipStart().getShapeFull().getShape() : o1.getRelationship().getShapeRelationshipEnd().getShapeFull().getShape(); CL o2Other = o2.getRelationship().getShapeRelationshipEnd().getShapeFull() == o2.getClassRelationship().getShapeFull() ? o2.getRelationship().getShapeRelationshipStart().getShapeFull().getShape() : o2.getRelationship().getShapeRelationshipEnd().getShapeFull().getShape(); return Double.compare(o1Other.getLevelXOnDiagram(), o2Other.getLevelXOnDiagram()); }
protected void setBinaries(Map<CLDevice, byte[]> binaries) { if (this.devices == null) { this.devices = new CLDevice[binaries.size()]; int iDevice = 0; for (CLDevice device : binaries.keySet()) this.devices[iDevice++] = device; } int nDevices = this.devices.length; NativeSize[] lengths = new NativeSize[nDevices]; cl_device_id[] deviceIds = new cl_device_id[nDevices]; Memory binariesArray = new Memory(Pointer.SIZE * nDevices); Memory[] binariesMems = new Memory[nDevices]; for (int iDevice = 0; iDevice < nDevices; iDevice++) { CLDevice device = devices[iDevice]; byte[] binary = binaries.get(device); Memory binaryMem = binariesMems[iDevice] = new Memory(binary.length); binaryMem.write(0, binary, 0, binary.length); binariesArray.setPointer(iDevice * Pointer.SIZE, binaryMem); lengths[iDevice] = toNS(binary.length); deviceIds[iDevice] = device.getEntity(); } PointerByReference binariesPtr = new PointerByReference(); binariesPtr.setPointer(binariesArray); IntBuffer errBuff = NIOUtils.directInts(1, ByteOrder.nativeOrder()); int previousAttempts = 0; IntBuffer statuses = NIOUtils.directInts(nDevices, ByteOrder.nativeOrder()); do { entity = CL.clCreateProgramWithBinary( context.getEntity(), nDevices, deviceIds, lengths, binariesPtr, statuses, errBuff); } while (failedForLackOfMemory(errBuff.get(0), previousAttempts++)); }
@Override protected int getInfo( cl_program entity, int infoTypeEnum, NativeSize size, Pointer out, NativeSizeByReference sizeOut) { return CL.clGetProgramInfo(entity, infoTypeEnum, size, out, sizeOut); }
/** Return all the kernels found in the program. */ public CLKernel[] createKernels() throws CLBuildException { synchronized (this) { if (!built) build(); } IntByReference pCount = new IntByReference(); int previousAttempts = 0; while (failedForLackOfMemory( CL.clCreateKernelsInProgram(getEntity(), 0, (cl_kernel[]) null, pCount), previousAttempts++)) {} int count = pCount.getValue(); cl_kernel[] kerns = new cl_kernel[count]; previousAttempts = 0; while (failedForLackOfMemory( CL.clCreateKernelsInProgram(getEntity(), count, kerns, pCount), previousAttempts++)) {} CLKernel[] kernels = new CLKernel[count]; for (int i = 0; i < count; i++) kernels[i] = new CLKernel(this, null, kerns[i]); return kernels; }
/** Find a kernel by its functionName, and optionally bind some arguments to it. */ public CLKernel createKernel(String name, Object... args) throws CLBuildException { synchronized (this) { if (!built) build(); } IntBuffer errBuff = NIOUtils.directInts(1, ByteOrder.nativeOrder()); cl_kernel kernel; int previousAttempts = 0; do { kernel = CL.clCreateKernel(getEntity(), name, errBuff); } while (failedForLackOfMemory(errBuff.get(0), previousAttempts++)); CLKernel kn = new CLKernel(this, name, kernel); kn.setArgs(args); return kn; }
public synchronized void allocate() { if (entity != null) throw new IllegalThreadStateException("Program was already allocated !"); if (passMacrosAsSources) { if (macros != null && !macros.isEmpty()) { StringBuilder b = new StringBuilder(); for (Map.Entry<String, Object> m : macros.entrySet()) b.append("#define " + m.getKey() + " " + m.getValue() + "\n"); this.sources.add(0, b.toString()); } } if (!"false".equals(System.getProperty("javacl.adjustDoubleExtension")) && !"0".equals(System.getenv("JAVACL_ADJUST_DOUBLE_EXTENSION"))) { for (int i = 0, len = sources.size(); i < len; i++) { String source = sources.get(i); for (CLDevice device : getDevices()) source = device.replaceDoubleExtensionByExtensionActuallyAvailable(source); sources.set(i, source); // TODO keep different sources for each device !!! } } String[] sources = this.sources.toArray(new String[this.sources.size()]); NativeSize[] lengths = new NativeSize[sources.length]; for (int i = 0; i < sources.length; i++) { lengths[i] = toNS(sources[i].length()); } IntBuffer errBuff = NIOUtils.directInts(1, ByteOrder.nativeOrder()); cl_program program; int previousAttempts = 0; do { program = CL.clCreateProgramWithSource( context.getEntity(), sources.length, sources, lengths, errBuff); } while (failedForLackOfMemory(errBuff.get(0), previousAttempts++)); entity = program; }
private static long getDevice(long platform, CLCapabilities platformCaps, int deviceType) { MemoryStack stack = stackPush(); try { IntBuffer pi = stack.mallocInt(1); checkCLError(clGetDeviceIDs(platform, deviceType, null, pi)); PointerBuffer devices = stack.mallocPointer(pi.get(0)); checkCLError(clGetDeviceIDs(platform, deviceType, devices, null)); for (int i = 0; i < devices.capacity(); i++) { long device = devices.get(i); CLCapabilities caps = CL.createDeviceCapabilities(device, platformCaps); if (!(caps.cl_khr_gl_sharing || caps.cl_APPLE_gl_sharing)) continue; return device; } } finally { stack.pop(); } return NULL; }
public Mandelbrot( long platform, CLCapabilities platformCaps, GLFWWindow window, int deviceType, boolean debugGL, int maxIterations) { this.platform = platform; this.window = window; this.maxIterations = maxIterations; IntBuffer size = BufferUtils.createIntBuffer(2); nglfwGetWindowSize(window.handle, memAddress(size), memAddress(size) + 4); ww = size.get(0); wh = size.get(1); nglfwGetFramebufferSize(window.handle, memAddress(size), memAddress(size) + 4); fbw = size.get(0); fbh = size.get(1); glfwMakeContextCurrent(window.handle); GLCapabilities glCaps = GL.createCapabilities(); if (!glCaps.OpenGL30) throw new RuntimeException("OpenGL 3.0 is required to run this demo."); debugProc = debugGL ? GLUtil.setupDebugMessageCallback() : null; glfwSwapInterval(0); errcode_ret = BufferUtils.createIntBuffer(1); try { // Find devices with GL sharing support { long device = getDevice(platform, platformCaps, deviceType); if (device == NULL) device = getDevice(platform, platformCaps, CL_DEVICE_TYPE_CPU); if (device == NULL) throw new RuntimeException("No OpenCL devices found with OpenGL sharing support."); this.device = device; this.deviceCaps = CL.createDeviceCapabilities(device, platformCaps); } // Create the context PointerBuffer ctxProps = BufferUtils.createPointerBuffer(7); switch (Platform.get()) { case WINDOWS: ctxProps .put(CL_GL_CONTEXT_KHR) .put(glfwGetWGLContext(window.handle)) .put(CL_WGL_HDC_KHR) .put(wglGetCurrentDC()); break; case LINUX: ctxProps .put(CL_GL_CONTEXT_KHR) .put(glfwGetGLXContext(window.handle)) .put(CL_GLX_DISPLAY_KHR) .put(glfwGetX11Display()); break; case MACOSX: ctxProps .put(APPLEGLSharing.CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE) .put(CGLGetShareGroup(CGLGetCurrentContext())); } ctxProps.put(CL_CONTEXT_PLATFORM).put(platform).put(NULL).flip(); clContext = clCreateContext( ctxProps, device, clContextCB = new CLContextCallback() { @Override public void invoke(long errinfo, long private_info, long cb, long user_data) { log(String.format("cl_context_callback\n\tInfo: %s", memUTF8(errinfo))); } }, NULL, errcode_ret); checkCLError(errcode_ret); // create command queues for every GPU, setup colormap and init kernels IntBuffer colorMapBuffer = BufferUtils.createIntBuffer(32 * 2); initColorMap(colorMapBuffer, 32, Color.BLUE, Color.GREEN, Color.RED); clColorMap = clCreateBuffer( clContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, colorMapBuffer, errcode_ret); checkCLError(errcode_ret); // create command queue and upload color map buffer clQueue = clCreateCommandQueue(clContext, device, NULL, errcode_ret); checkCLError(errcode_ret); // load program(s) if (deviceType == CL_DEVICE_TYPE_GPU) log("OpenCL Device Type: GPU (Use -forceCPU to use CPU)"); else log("OpenCL Device Type: CPU"); log("Max Iterations: " + maxIterations + " (Use -iterations <count> to change)"); log("Display resolution: " + ww + "x" + wh + " (Use -res <width> <height> to change)"); log("OpenGL glCaps.GL_ARB_sync = " + glCaps.GL_ARB_sync); log("OpenGL glCaps.GL_ARB_cl_event = " + glCaps.GL_ARB_cl_event); buildProgram(); // Detect GLtoCL synchronization method syncGLtoCL = !glCaps.GL_ARB_cl_event; // GL3.2 or ARB_sync implied log(syncGLtoCL ? "GL to CL sync: Using clFinish" : "GL to CL sync: Using OpenCL events"); // Detect CLtoGL synchronization method syncCLtoGL = !deviceCaps.cl_khr_gl_event; log( syncCLtoGL ? "CL to GL sync: Using glFinish" : "CL to GL sync: Using implicit sync (cl_khr_gl_event)"); vao = glGenVertexArrays(); glBindVertexArray(vao); vbo = glGenBuffers(); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData( GL_ARRAY_BUFFER, stackPush() .floats( 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f), GL_STATIC_DRAW); stackPop(); vsh = glCreateShader(GL_VERTEX_SHADER); glShaderSource( vsh, "#version 150\n" + "\n" + "uniform mat4 projection;\n" + "\n" + "uniform vec2 size;\n" + "\n" + "in vec2 posIN;\n" + "in vec2 texIN;\n" + "\n" + "out vec2 texCoord;\n" + "\n" + "void main(void) {\n" + "\tgl_Position = projection * vec4(posIN * size, 0.0, 1.0);\n" + "\ttexCoord = texIN;\n" + "}"); glCompileShader(vsh); String log = glGetShaderInfoLog(vsh, glGetShaderi(vsh, GL_INFO_LOG_LENGTH)); if (!log.isEmpty()) log(String.format("VERTEX SHADER LOG: %s", log)); fsh = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource( fsh, "#version 150\n" + "\n" + "uniform isampler2D mandelbrot;\n" + "\n" + "in vec2 texCoord;\n" + "\n" + "out vec4 fragColor;\n" + "\n" + "void main(void) {\n" + "\tfragColor = texture(mandelbrot, texCoord) / 255.0;\n" + "}"); glCompileShader(fsh); log = glGetShaderInfoLog(fsh, glGetShaderi(fsh, GL_INFO_LOG_LENGTH)); if (!log.isEmpty()) log(String.format("FRAGMENT SHADER LOG: %s", log)); glProgram = glCreateProgram(); glAttachShader(glProgram, vsh); glAttachShader(glProgram, fsh); glLinkProgram(glProgram); log = glGetProgramInfoLog(glProgram, glGetProgrami(glProgram, GL_INFO_LOG_LENGTH)); if (!log.isEmpty()) log(String.format("PROGRAM LOG: %s", log)); int posIN = glGetAttribLocation(glProgram, "posIN"); int texIN = glGetAttribLocation(glProgram, "texIN"); glVertexAttribPointer(posIN, 2, GL_FLOAT, false, 4 * 4, 0); glVertexAttribPointer(texIN, 2, GL_FLOAT, false, 4 * 4, 2 * 4); glEnableVertexAttribArray(posIN); glEnableVertexAttribArray(texIN); projectionUniform = glGetUniformLocation(glProgram, "projection"); sizeUniform = glGetUniformLocation(glProgram, "size"); glUseProgram(glProgram); glUniform1i(glGetUniformLocation(glProgram, "mandelbrot"), 0); } catch (Exception e) { // TODO: cleanup throw new RuntimeException(e); } glDisable(GL_DEPTH_TEST); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); initGLObjects(); glFinish(); setKernelConstants(); glfwSetWindowSizeCallback( window.handle, window.windowsizefun = new GLFWWindowSizeCallback() { @Override public void invoke(long window, final int width, final int height) { if (width == 0 || height == 0) return; events.add( new Runnable() { @Override public void run() { Mandelbrot.this.ww = width; Mandelbrot.this.wh = height; shouldInitBuffers = true; } }); } }); glfwSetFramebufferSizeCallback( window.handle, window.framebuffersizefun = new GLFWFramebufferSizeCallback() { @Override public void invoke(long window, final int width, final int height) { if (width == 0 || height == 0) return; events.add( new Runnable() { @Override public void run() { Mandelbrot.this.fbw = width; Mandelbrot.this.fbh = height; shouldInitBuffers = true; } }); } }); glfwSetKeyCallback( window.handle, window.keyfun = new GLFWKeyCallback() { @Override public void invoke(long window, int key, int scancode, int action, int mods) { switch (key) { case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: ctrlDown = action == GLFW_PRESS; return; } if (action != GLFW_PRESS) return; switch (key) { case GLFW_KEY_ESCAPE: glfwSetWindowShouldClose(window, GLFW_TRUE); break; case GLFW_KEY_D: events.offer( new Runnable() { @Override public void run() { doublePrecision = !doublePrecision; log("DOUBLE PRECISION IS NOW: " + (doublePrecision ? "ON" : "OFF")); rebuild = true; } }); break; case GLFW_KEY_HOME: events.offer( new Runnable() { @Override public void run() { offsetX = -0.5; offsetY = 0.0; zoom = 1.0; } }); break; } } }); glfwSetMouseButtonCallback( window.handle, window.mousebuttonfun = new GLFWMouseButtonCallback() { @Override public void invoke(long window, int button, int action, int mods) { if (button != GLFW_MOUSE_BUTTON_LEFT) return; dragging = action == GLFW_PRESS; if (dragging) { dragging = true; dragX = mouseX; dragY = mouseY; dragOffsetX = offsetX; dragOffsetY = offsetY; } } }); glfwSetCursorPosCallback( window.handle, window.cursorposfun = new GLFWCursorPosCallback() { @Override public void invoke(long window, double xpos, double ypos) { mouseX = xpos; mouseY = wh - ypos; if (dragging) { offsetX = dragOffsetX + transformX(dragX - mouseX); offsetY = dragOffsetY + transformY(dragY - mouseY); } } }); glfwSetScrollCallback( window.handle, window.scrollfun = new GLFWScrollCallback() { @Override public void invoke(long window, double xoffset, double yoffset) { if (yoffset == 0) return; double scrollX = mouseX - ww * 0.5; double scrollY = mouseY - wh * 0.5; double zoomX = transformX(scrollX); double zoomY = transformY(scrollY); zoom *= (1.0 - yoffset * (ctrlDown ? 0.25 : 0.05)); offsetX += zoomX - transformX(scrollX); offsetY += zoomY - transformY(scrollY); } }); }
@Override protected void clear() { error(CL.clReleaseProgram(getEntity())); }
/** Returns the context of this program */ public synchronized CLProgram build() throws CLBuildException { if (built) throw new IllegalThreadStateException("Program was already built !"); String contentSignature = null; File cacheFile = null; boolean readBinaries = false; if (isCached()) { try { contentSignature = computeCacheSignature(); byte[] sha = java.security.MessageDigest.getInstance("MD5") .digest(contentSignature.getBytes(textEncoding)); StringBuilder shab = new StringBuilder(); for (byte b : sha) shab.append(Integer.toHexString(b & 0xff)); String hash = shab.toString(); cacheFile = new File(JavaCL.userCacheDir, hash); if (cacheFile.exists()) { Pair<Map<CLDevice, byte[]>, String> bins = readBinaries( Arrays.asList(getDevices()), contentSignature, new FileInputStream(cacheFile)); setBinaries(bins.getFirst()); this.source = bins.getSecond(); assert log(Level.INFO, "Read binaries cache from '" + cacheFile + "'"); readBinaries = true; } } catch (Exception ex) { assert log(Level.WARNING, "Failed to load cached program", ex); entity = null; } } if (entity == null) allocate(); Runnable deleteTempFiles = null; if (!readBinaries) try { deleteTempFiles = copyIncludesToTemporaryDirectory(); } catch (IOException ex) { throw new CLBuildException(this, ex.toString(), Collections.EMPTY_LIST); } int nDevices = devices.length; cl_device_id[] deviceIds = null; if (nDevices != 0) { deviceIds = new cl_device_id[nDevices]; for (int i = 0; i < nDevices; i++) deviceIds[i] = devices[i].getEntity(); } int err = CL.clBuildProgram( getEntity(), nDevices, deviceIds, readBinaries ? null : getOptionsString(), null, null); // int err = CL.clBuildProgram(getEntity(), 0, null, getOptionsString(), null, null); if (err != CL_SUCCESS) { // BUILD_PROGRAM_FAILURE) { NativeSizeByReference len = new NativeSizeByReference(); int bufLen = 2048 * 32; // TODO find proper size Memory buffer = new Memory(bufLen); HashSet<String> errs = new HashSet<String>(); if (deviceIds == null) { error( CL.clGetProgramBuildInfo( getEntity(), null, CL_PROGRAM_BUILD_LOG, toNS(bufLen), buffer, len)); String s = buffer.getString(0); errs.add(s); } else for (cl_device_id device : deviceIds) { error( CL.clGetProgramBuildInfo( getEntity(), device, CL_PROGRAM_BUILD_LOG, toNS(bufLen), buffer, len)); String s = buffer.getString(0); errs.add(s); } throw new CLBuildException(this, "Compilation failure : " + errorString(err), errs); } built = true; if (deleteTempFiles != null) deleteTempFiles.run(); if (isCached() && !readBinaries) { JavaCL.userCacheDir.mkdirs(); try { Map<CLDevice, byte[]> binaries = getBinaries(); if (!binaries.isEmpty()) { writeBinaries( getBinaries(), getSource(), contentSignature, new FileOutputStream(cacheFile)); assert log(Level.INFO, "Wrote binaries cache to '" + cacheFile + "'"); } } catch (Exception ex) { new IOException("[JavaCL] Failed to cache program", ex).printStackTrace(); } } return this; }