@Test public void copyLimitedSlicedBuffersTest() { final int size = 4200 * SIZEOF_INT; // Arbitrary number that is a multiple of SIZEOF_INT; final int padding = 307; // Totally arbitrary number > 0 final CLContext context = CLContext.create(); final CLCommandQueue queue = context.getDevices()[0].createCommandQueue(); // Make a buffer that is offset relative to the originally allocated position and has a limit // that is // not equal to the capacity to test whether all these attributes are correctly handled. ByteBuffer hostBuffer = ByteBuffer.allocateDirect(size + padding); hostBuffer.position(padding / 2); // Offset the original buffer hostBuffer = hostBuffer.slice(); // Slice it to have a new buffer that starts at the offset hostBuffer.limit(size); hostBuffer.order(ByteOrder.nativeOrder()); // Necessary for comparisons to work later on. fillBuffer(hostBuffer, 12345); final CLBuffer<ByteBuffer> bufferA = context.createBuffer(size).cloneWith(hostBuffer); final CLBuffer<ByteBuffer> bufferB = context.createByteBuffer(size); queue .putWriteBuffer(bufferA, false) .putCopyBuffer(bufferA, bufferB, bufferA.getNIOSize()) .putReadBuffer(bufferB, true) .finish(); hostBuffer.rewind(); bufferB.buffer.rewind(); checkIfEqual(hostBuffer, bufferB.buffer, size / SIZEOF_INT); context.release(); }
@Test public void bufferWithHostPointerTest() { out.println(" - - - highLevelTest; host pointer test - - - "); final int elements = NUM_ELEMENTS; final CLContext context = CLContext.create(); final ByteBuffer buffer = Buffers.newDirectByteBuffer(elements * SIZEOF_INT); // fill only first read buffer -> we will copy the payload to the second later. fillBuffer(buffer, 12345); final CLCommandQueue queue = context.getDevices()[0].createCommandQueue(); final Mem[] bufferConfig = new Mem[] {Mem.COPY_BUFFER, Mem.USE_BUFFER}; for (int i = 0; i < bufferConfig.length; i++) { out.println("testing with " + bufferConfig[i] + " config"); final CLBuffer<ByteBuffer> clBufferA = context.createBuffer(buffer, Mem.READ_ONLY, bufferConfig[i]); final CLBuffer<ByteBuffer> clBufferB = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY); // asynchronous write of data to GPU device, blocking read later to get the computed results // back. queue .putCopyBuffer(clBufferA, clBufferB, clBufferA.buffer.capacity()) // copy A -> B .putReadBuffer(clBufferB, true) // read B .finish(); assertEquals(2, context.getMemoryObjects().size()); clBufferA.release(); assertEquals(1, context.getMemoryObjects().size()); clBufferB.release(); assertEquals(0, context.getMemoryObjects().size()); // uploading worked when a==b. out.println("validating computed results..."); checkIfEqual(clBufferA.buffer, clBufferB.buffer, elements); out.println("results are valid"); } context.release(); }
@Test public void cloneWithLimitedBufferTest() { final int elements = NUM_ELEMENTS; final int padding = 312; // Arbitrary number final CLContext context = CLContext.create(); final IntBuffer hostBuffer = ByteBuffer.allocateDirect((elements + padding) * SIZEOF_INT).asIntBuffer(); hostBuffer.limit(elements); final CLBuffer<?> deviceBuffer = context.createBuffer(elements * SIZEOF_INT).cloneWith(hostBuffer); assertEquals(elements, deviceBuffer.getCLCapacity()); assertEquals(elements * SIZEOF_INT, deviceBuffer.getNIOSize()); assertEquals(elements, deviceBuffer.getNIOCapacity()); context.release(); }
@Test public void subBufferTest02FloatBuffer() { out.println(" - - - subBufferTest - - - "); @SuppressWarnings("unchecked") final CLPlatform platform = CLPlatform.getDefault(version(CL_1_1)); if (platform == null) { out.println("aborting subBufferTest"); return; } final CLContext context = CLContext.create(platform); try { final int subelements = 5; final long lMaxAlignment = context.getMaxMemBaseAddrAlign(); final int iMaxAlignment = Bitstream.uint32LongToInt(lMaxAlignment); System.err.println( "XXX: maxAlignment " + lMaxAlignment + ", 0x" + Long.toHexString(lMaxAlignment) + ", (int)" + iMaxAlignment + ", (int)0x" + Integer.toHexString(iMaxAlignment)); if (-1 == iMaxAlignment) { throw new RuntimeException( "Cannot handle MaxMemBaseAddrAlign > MAX_INT, has 0x" + Long.toHexString(lMaxAlignment)); } // FIXME: See Bug 979: Offset/Alignment via offset calculation per element-count is faulty! final int floatsPerAlignment = iMaxAlignment / Buffers.SIZEOF_FLOAT; // device + direct buffer final CLBuffer<FloatBuffer> buffer = context.createFloatBuffer(floatsPerAlignment + subelements); assertFalse(buffer.isSubBuffer()); assertNotNull(buffer.getSubBuffers()); assertTrue(buffer.getSubBuffers().isEmpty()); final CLSubBuffer<FloatBuffer> subBuffer = buffer.createSubBuffer(floatsPerAlignment, subelements); assertTrue(subBuffer.isSubBuffer()); assertEquals(subelements, subBuffer.getBuffer().capacity()); assertEquals(floatsPerAlignment, subBuffer.getOffset()); assertEquals(iMaxAlignment, subBuffer.getCLOffset()); assertEquals(buffer, subBuffer.getParent()); assertEquals(1, buffer.getSubBuffers().size()); assertEquals(subBuffer.getCLCapacity(), subBuffer.getBuffer().capacity()); subBuffer.release(); assertEquals(0, buffer.getSubBuffers().size()); } finally { context.release(); } }
@Test public void subBufferTest01ByteBuffer() { out.println(" - - - subBufferTest - - - "); @SuppressWarnings("unchecked") final CLPlatform platform = CLPlatform.getDefault(version(CL_1_1)); if (platform == null) { out.println("aborting subBufferTest"); return; } final CLContext context = CLContext.create(platform); try { final int subelements = 5; final long lMaxAlignment = context.getMaxMemBaseAddrAlign(); final int iMaxAlignment = Bitstream.uint32LongToInt(lMaxAlignment); System.err.println( "XXX: maxAlignment " + lMaxAlignment + ", 0x" + Long.toHexString(lMaxAlignment) + ", (int)" + iMaxAlignment + ", (int)0x" + Integer.toHexString(iMaxAlignment)); if (-1 == iMaxAlignment) { throw new RuntimeException( "Cannot handle MaxMemBaseAddrAlign > MAX_INT, has 0x" + Long.toHexString(lMaxAlignment)); } // device only final CLBuffer<?> buffer = context.createBuffer(iMaxAlignment + subelements); assertFalse(buffer.isSubBuffer()); assertNotNull(buffer.getSubBuffers()); assertTrue(buffer.getSubBuffers().isEmpty()); final CLSubBuffer<?> subBuffer = buffer.createSubBuffer(iMaxAlignment, subelements); assertTrue(subBuffer.isSubBuffer()); assertEquals(subelements, subBuffer.getCLSize()); assertEquals(iMaxAlignment, subBuffer.getOffset()); assertEquals(iMaxAlignment, subBuffer.getCLOffset()); assertEquals(buffer, subBuffer.getParent()); assertEquals(1, buffer.getSubBuffers().size()); subBuffer.release(); assertEquals(0, buffer.getSubBuffers().size()); } finally { context.release(); } }
@Test public void createBufferFromLimitedBuffer() { final int elements = NUM_ELEMENTS; final int padding = 19 * SIZEOF_INT * 2; // Totally arbitrary number > 0 divisible by 2*SIZEOF_INT final CLContext context = CLContext.create(); // Make a buffer that is offset relative to the originally allocated position and has a // limit that is // not equal to the capacity to test whether all these attributes are correctly handled. ByteBuffer byteBuffer = ByteBuffer.allocateDirect(elements * SIZEOF_INT + padding); byteBuffer.position(padding / 2); // Offset the original buffer IntBuffer intBuffer = byteBuffer .slice() .order(ByteOrder.nativeOrder()) .asIntBuffer(); // Slice it to have a new buffer that starts at the offset intBuffer.limit(elements); final CLBuffer<IntBuffer> deviceBuffer = context.createBuffer(intBuffer); assertEquals(elements, deviceBuffer.getCLCapacity()); assertEquals(elements * SIZEOF_INT, deviceBuffer.getNIOSize()); assertEquals(elements, deviceBuffer.getNIOCapacity()); }
@Test public void destructorCallbackTest() throws InterruptedException { out.println(" - - - destructorCallbackTest - - - "); @SuppressWarnings("unchecked") final CLPlatform platform = CLPlatform.getDefault(version(CL_1_1)); if (platform == null) { out.println("aborting destructorCallbackTest"); return; } final CLContext context = CLContext.create(platform); try { final CLBuffer<?> buffer = context.createBuffer(32); final CountDownLatch countdown = new CountDownLatch(1); buffer.registerDestructorCallback( new CLMemObjectListener() { public void memoryDeallocated(final CLMemory<?> mem) { out.println("buffer released"); assertEquals(mem, buffer); countdown.countDown(); } }); buffer.release(); countdown.await(2, TimeUnit.SECONDS); assertEquals(countdown.getCount(), 0); } finally { context.release(); } }
@Test public void createBufferTest() { out.println(" - - - highLevelTest; create buffer test - - - "); final CLContext context = CLContext.create(); try { final int size = 6; final CLBuffer<ByteBuffer> bb = context.createByteBuffer(size); final CLBuffer<ShortBuffer> sb = context.createShortBuffer(size); final CLBuffer<IntBuffer> ib = context.createIntBuffer(size); final CLBuffer<LongBuffer> lb = context.createLongBuffer(size); final CLBuffer<FloatBuffer> fb = context.createFloatBuffer(size); final CLBuffer<DoubleBuffer> db = context.createDoubleBuffer(size); final List<CLMemory<? extends Buffer>> buffers = context.getMemoryObjects(); assertEquals(6, buffers.size()); assertEquals(1, bb.getElementSize()); assertEquals(2, sb.getElementSize()); assertEquals(4, ib.getElementSize()); assertEquals(8, lb.getElementSize()); assertEquals(4, fb.getElementSize()); assertEquals(8, db.getElementSize()); final ByteBuffer anotherNIO = newDirectByteBuffer(2); for (final CLMemory<? extends Buffer> memory : buffers) { final CLBuffer<? extends Buffer> buffer = (CLBuffer<? extends Buffer>) memory; final Buffer nio = buffer.getBuffer(); assertEquals(nio.capacity(), buffer.getCLCapacity()); assertEquals(buffer.getNIOSize(), buffer.getCLSize()); assertEquals(sizeOfBufferElem(nio), buffer.getElementSize()); assertEquals(nio.capacity() * sizeOfBufferElem(nio), buffer.getCLSize()); final CLBuffer<ByteBuffer> clone = buffer.cloneWith(anotherNIO); assertEquals(buffer.ID, clone.ID); assertTrue(clone.equals(buffer)); assertTrue(buffer.equals(clone)); assertEquals(buffer.getCLSize(), clone.getCLCapacity()); assertEquals(buffer.getCLSize(), clone.getCLSize()); assertEquals(anotherNIO.capacity(), clone.getNIOCapacity()); } } finally { context.release(); } }