public CLKernels() throws IOException, CLBuildException { this( JavaCL.createBestContext( DeviceFeature.DoubleSupport, DeviceFeature.MaxComputeUnits ).createDefaultQueue() ); } public CLKernels(CLQueue queue) throws IOException, CLBuildException {
/** * Create a program with all the C source code content provided as argument. * @param srcs list of the content of source code for the program * @return a program that needs to be built */ public CLProgram createProgram(String... srcs) { return createProgram(null, srcs); }
CLContext(CLPlatform platform, Pointer<SizeT> deviceIds, long context) { super(context); this.platform = platform; this.deviceIds = deviceIds; if (getByteOrder() == null) { JavaCL.log(Level.WARNING, "The devices in this context have mismatching byte orders. This mandates the use of __attribute__((endian(host))) in kernel sources or *very* careful use of buffers to avoid facing endianness issues"); } }
public CLQueue createDefaultOutOfOrderQueueIfPossible() { try { return createDefaultOutOfOrderQueue(); } catch (Throwable th) {//CLException.InvalidQueueProperties ex) { return createDefaultQueue(); } }
/** * Create an ARGB input 2D image with the content provided * @param allowUnoptimizingDirectRead Some images expose their internal data for direct read, leading to performance increase during the creation of the OpenCL image. However, direct access to the image data disables some Java2D optimizations for this image, leading to degraded performance in subsequent uses with AWT/Swing. */ public CLImage2D createImage2D(CLMem.Usage usage, Image image, boolean allowUnoptimizingDirectRead) { int width = image.getWidth(null), height = image.getHeight(null); ImageInfo info = ImageIOUtils.getImageInfo(image); return createImage2D( usage, info.clImageFormat, width, height, 0, info.dataGetter.getData(image, null, true, allowUnoptimizingDirectRead, getByteOrder()), true); }
public static ByteOrder checkByteOrderNeededForBuffers(CLDevice device) { CLContext context = JavaCL.createContext((Map)null, device); CLQueue queue = context.createDefaultQueue(); try { int n = 16; inPtr.order(ByteOrder.LITTLE_ENDIAN).set(LITTLE_INDEX, testValue); CLBuffer<Float> inOut = context.createFloatBuffer(CLMem.Usage.InputOutput, inPtr); CLBuffer<Integer> success = context.createIntBuffer(CLMem.Usage.Output, n); "}"; CLKernel test = context.createProgram(src).createKernel("compare_endiannesses"); test.setArgs(inOut, success); test.enqueueNDRange(queue, new int[] { n }, new int[] { 1 }); } finally { queue.release(); context.release();
public static FloatBuffer add(FloatBuffer a, FloatBuffer b) throws CLBuildException { int n = a.capacity(); CLContext context = JavaCL.createBestContext(); CLQueue queue = context.createDefaultQueue(); String source = "__kernel void addFloats(__global const float* a, __global const float* b, __global float* output) " + "{ " + " int i = get_global_id(0); " + " output[i] = a[i] + b[i]; " + "} "; CLKernel kernel = context.createProgram(source).createKernel("addFloats"); CLFloatBuffer aBuf = context.createFloatBuffer(CLMem.Usage.Input, a, true); CLFloatBuffer bBuf = context.createFloatBuffer(CLMem.Usage.Input, b, true); CLFloatBuffer outBuf = context.createFloatBuffer(CLMem.Usage.Output, n); kernel.setArgs(aBuf, bBuf, outBuf); kernel.enqueueNDRange(queue, new int[]{n}); queue.finish(); return outBuf.read(queue); } }
private synchronized CLImage2D process(CLKernel kernel, CLImage2D in, float[] amt) { CLQueue queue = context.createDefaultQueue(); CLImage2D out = context.createImage2D(CLMem.Usage.Output, in.getFormat(), in.getWidth(), in.getHeight()); process(kernel, queue, in, amt, out).waitFor(); queue.release(); return out; }
public static void main(String[] args) { CLContext context = JavaCL.createBestContext(CLPlatform.DeviceFeature.GPU); System.out.println(context); int n = 128;// * 128; // Pointer<Integer> p = Pointer.allocateInts(n); for (int i = 0; i < 100000; i++) { // if ((i & 0xff) == 0xff) System.out.print("."); CLQueue queue = context.createDefaultQueue(); CLBuffer<Integer> buffer = context.createByteBuffer(CLMem.Usage.Output, 4 * n).as(Integer.class);//p); CLProgram program = context.createProgram("kernel void f(global int* input, int n) {\n" + "int i = get_global_id(0);\n" + "if (i >= n) return;\n" + "input[i] = i;\n" + "}"); CLKernel kernel = program.createKernel("f"); for (int j = 0; j < 100; j++) { kernel.setArgs(buffer, n); kernel.enqueueNDRange(queue, new int[] { n }); } queue.finish(); queue.release(); kernel.release(); program.release(); buffer.release(); } context.release(); } }
/** * Calls <a href="http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateBuffer.html">clCreateBuffer</a>.<br> * Create a <code>CLBuffer<Byte></code> OpenCL buffer big enough to hold 'length' values of type byte. * @param usage Usage intended for the pointer in OpenCL kernels : a pointer created with {@link CLMem.Usage#Input} cannot be written to in a kernel. * @param elementCount Length of the buffer expressed in elements (for instance, a <code>CLBuffer<Byte></code> of length 10 will actually contain 10 * 1 bytes, as bytes are 1-bytes-long) * @return A new buffer allocated on this context. */ public CLBuffer<Byte> createByteBuffer(CLMem.Usage usage, long elementCount) { return createBuffer(usage, Byte.class, elementCount); }
@Test(expected = IllegalArgumentException.class) public void testMismatchingOrder() { context.createBuffer(CLMem.Usage.InputOutput, allocateFloats(10).order(otherOrder(context.getByteOrder()))); } @Test
public <T> Object testArrayArg(String type, Object array, Class<T> targetType) { long size = BridJ.sizeOf(targetType); long length = Array.getLength(array); CLBuffer<Byte> out = context.createByteBuffer(Usage.Output, size * length); StringBuilder b = new StringBuilder( "#pragma OPENCL EXTENSION cl_khr_fp64 : enable\n" + "kernel void f(" + type + length + " arg, global " + type + "* out, long length) {\n"); for (long i = 0; i < length; i++) { b.append("out[" + i + "] = arg.s" + (i < 10 ? i + "" : ((char)((int)'a' + (i - 10))) + "") + ";\n"); } b.append("}\n"); System.out.println(b); CLKernel k = context.createProgram(b.toString()).createKernel("f", array, out, length); CLEvent e = k.enqueueTask(queue); return out.as(targetType).read(queue, e).getArray(); }
AbstractCommon(CLDevice device) { this.device = device; platform = device.getPlatform(); context = platform.createContext(null, device); queue = context.createDefaultQueue(); device = context.getDevices()[0]; formatsRead2D = context.getSupportedImageFormats(CLMem.Flags.ReadOnly, CLMem.ObjectType.Image2D); formatsWrite2D = context.getSupportedImageFormats(CLMem.Flags.WriteOnly, CLMem.ObjectType.Image2D); formatsRead3D = context.getSupportedImageFormats(CLMem.Flags.ReadOnly, CLMem.ObjectType.Image3D); formatsWrite3D = context.getSupportedImageFormats(CLMem.Flags.WriteOnly, CLMem.ObjectType.Image3D); formatsReadWrite2D = context.getSupportedImageFormats(CLMem.Flags.ReadWrite, CLMem.ObjectType.Image2D); formatsReadWrite3D = context.getSupportedImageFormats(CLMem.Flags.ReadWrite, CLMem.ObjectType.Image3D); }
CLEvent createEvent() { CLContext c = createContext(); return c.createBuffer(CLMem.Usage.Input, Integer.class, 10).mapLater(c.createDefaultQueue(), CLMem.MapFlags.Read).getSecond(); }
/** * Restore a program previously saved with {@link CLProgram#store(java.io.OutputStream) } * @param in will be closed * @return a CLProgram object representing the previously saved program * @throws IOException */ public CLProgram loadProgram(InputStream in) throws IOException { Pair<Map<CLDevice, byte[]>, String> binaries = CLProgram.readBinaries(Arrays.asList(getDevices()), null, in); return createProgram(binaries.getFirst(), binaries.getSecond()); }
bb.order(context.getByteOrder()); final FloatBuffer fb = bb.asFloatBuffer(); floatData = context.createFloatBuffer(Usage.Input, fb, true);
magicNumber, realResolution, context.createIntBuffer(CLMem.Usage.Output, results, false), ); } else { CLProgram program = context.createProgram(src).build(); magicNumber, realResolution, context.createIntBuffer(CLMem.Usage.Output, results, false) );
/** * Calls <a href="http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateImage2D.html">clCreateImage2D</a>.<br> * @param usage Usage intended for the image. * @param format Format of the image. * @param width Image width * @param height Image height * @return A new image allocated on this context. * @param rowPitch Row pitch. */ public CLImage2D createImage2D(CLMem.Usage usage, CLImageFormat format, long width, long height, long rowPitch) { return createImage2D(usage, format, width, height, rowPitch, null, false); }
gradients = context.createFloatBuffer(CLMem.Usage.InputOutput, dataSize), directions = context.createFloatBuffer(CLMem.Usage.InputOutput, dataSize); context.createIntBuffer(CLMem.Usage.Input, IntBuffer.wrap(pixels), true).asCLByteBuffer(), width, height, CLIntBuffer gradientPixels = context.createIntBuffer(CLMem.Usage.Output, dataSize); CLIntBuffer directionPixels = context.createIntBuffer(CLMem.Usage.Output, dataSize);
/** * Calls <a href="http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateBuffer.html">clCreateBuffer</a>.<br> * Create a <code>CLBuffer<Float></code> OpenCL buffer big enough to hold the valid values of the provided data pointer. * @param usage Usage intended for the pointer in OpenCL kernels : a pointer created with {@link CLMem.Usage#Input} cannot be written to in a kernel. * @param data Host data to copy to the buffer * @return A new buffer allocated on this context. */ public CLBuffer<Float> createFloatBuffer(CLMem.Usage usage, Pointer<Float> data) { return createFloatBuffer(usage, data, true); } /**