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;
}
