Skip to content

Commit

Permalink
added a few tests for event profiling and enums.
Browse files Browse the repository at this point in the history 
fixed bug in LocalMemType and Mem enum valueOf(int foo) methods.
  • Loading branch information
@mbien
mbien committed Feb 13, 2010
1 parent a93e453 commit 62d9a63
Show file tree
Hide file tree
Showing 5 changed files with 168 additions and 63 deletions.
4 changes: 2 additions & 2 deletions src/com/mbien/opencl/CLDevice.java
View file
Expand Up @@ -746,9 +746,9 @@ private LocalMemType(int type) {
*/
public static LocalMemType valueOf(int clLocalCacheType) {
if(clLocalCacheType == CL_GLOBAL)
return LOCAL;
else if(clLocalCacheType == CL_LOCAL)
return GLOBAL;
else if(clLocalCacheType == CL_LOCAL)
return LOCAL;
return null;
}

Expand Down
2 changes: 2 additions & 0 deletions src/com/mbien/opencl/CLMemory.java
View file
Expand Up @@ -202,6 +202,8 @@ public static Mem valueOf(int bufferFlag) {
return Mem.READ_WRITE;
case CL_MEM_READ_ONLY:
return Mem.READ_ONLY;
case CL_MEM_WRITE_ONLY:
return Mem.WRITE_ONLY;
case CL_MEM_USE_HOST_PTR:
return Mem.USE_BUFFER;
case(CL_MEM_ALLOC_HOST_PTR):
Expand Down
170 changes: 118 additions & 52 deletions test/com/mbien/opencl/CLConcurrencyTest.java → .../com/mbien/opencl/CLCommandQueueTest.java
View file
@@ -1,52 +1,82 @@
package com.mbien.opencl;

import com.mbien.opencl.CLCommandQueue.Mode;
import com.mbien.opencl.CLMemory.Mem;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.EnumSet;
import org.junit.Test;

import static org.junit.Assert.*;
import static java.lang.System.*;
import static com.mbien.opencl.TestUtils.*;
import static com.mbien.opencl.CLEvent.*;
import static com.sun.gluegen.runtime.BufferFactory.*;

/**
*
* @author Michael Bien
*/
public class CLConcurrencyTest {
public class CLCommandQueueTest {

@Test
public void testEvents() throws IOException {
private final int groupSize = 256;

@Test
public void enumsTest() {

//CLCommandQueueEnums
EnumSet<Mode> queueMode = Mode.valuesOf(CL.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL.CL_QUEUE_PROFILING_ENABLE);
assertTrue(queueMode.contains(Mode.OUT_OF_ORDER_EXEC_MODE));
assertTrue(queueMode.contains(Mode.PROFILING_MODE));

assertNotNull(Mode.valuesOf(0));
assertEquals(0, Mode.valuesOf(0).size());
for (Mode mode : Mode.values()) {
assertEquals(mode, Mode.valueOf(mode.QUEUE_MODE));
}

// CLEvent enums
for (ProfilingCommand cmd : ProfilingCommand.values()) {
assertEquals(cmd, ProfilingCommand.valueOf(cmd.COMMAND));
}

for (CommandType type : CommandType.values()) {
assertEquals(type, CommandType.valueOf(type.TYPE));
}

for (ExecutionStatus status : ExecutionStatus.values()) {
assertEquals(status, ExecutionStatus.valueOf(status.STATUS));
}

}

@Test
public void eventsTest() throws IOException {

out.println(" - - - event synchronization test - - - ");

final int groupSize = 256;
final int elements = roundUp(groupSize, ONE_MB/SIZEOF_INT * 5); // 5MB per buffer
final int elements = roundUp(groupSize, ONE_MB / SIZEOF_INT * 5); // 5MB per buffer

CLContext context = CLContext.create();

CLBuffer<ByteBuffer> clBufferA = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferB = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferC = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferD = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferA = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferB = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferC = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferD = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);

fillBuffer(clBufferA.buffer, 12345);
fillBuffer(clBufferB.buffer, 67890);

CLProgram program = context.createProgram(getClass().getResourceAsStream("testkernels.cl")).build();

CLKernel vectorAddKernel = program.createCLKernel("VectorAddGM")
.setArg(3, elements);

CLKernel vectorAddKernel = program.createCLKernel("VectorAddGM").setArg(3, elements);
CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue();

final CLEventList events = new CLEventList(2);

assertEquals(0, events.size());

queue.putWriteBuffer(clBufferA, false, events) // write A
.putWriteBuffer(clBufferB, false, events); // write B
queue.putWriteBuffer(clBufferA, false, events) // write A
.putWriteBuffer(clBufferB, false, events);// write B

assertEquals(2, events.size());
queue.putWaitForEvents(events, true);
Expand All @@ -70,56 +100,100 @@ public void testEvents() throws IOException {
events.release();

checkIfEqual(clBufferC.buffer, clBufferD.buffer, elements);


context.release();


out.println("results are valid");

}
}
@Test
public void profilingEventsTest() throws IOException {

out.println(" - - - event synchronization test - - - ");

final int elements = roundUp(groupSize, ONE_MB / SIZEOF_INT * 5); // 5MB per buffer

CLContext context = CLContext.create();

CLBuffer<ByteBuffer> clBufferA = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferB = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
CLBuffer<ByteBuffer> clBufferC = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);

fillBuffer(clBufferA.buffer, 12345);
fillBuffer(clBufferB.buffer, 67890);

CLProgram program = context.createProgram(getClass().getResourceAsStream("testkernels.cl")).build();
CLKernel vectorAddKernel = program.createCLKernel("VectorAddGM").setArg(3, elements);
CLCommandQueue queue = context.getCLDevices()[0].createCommandQueue(Mode.PROFILING_MODE);

@Test
public void concurrencyTest() throws IOException, InterruptedException {
queue.putWriteBuffer(clBufferA, true) // write A
.putWriteBuffer(clBufferB, true);// write B

final CLEventList events = new CLEventList(1);

assertEquals(0, events.size());

vectorAddKernel.setArgs(clBufferA, clBufferB, clBufferC); // C = A+B
queue.put1DRangeKernel(vectorAddKernel, 0, elements, groupSize, events);

assertEquals(1, events.size());
CLEvent probe = events.getEvent(0);
out.println(probe);

queue.putWaitForEvents(events, true);
assertEquals(CLEvent.ExecutionStatus.COMPLETE, probe.getStatus());

out.println(probe);
long time = probe.getProfilingInfo(CLEvent.ProfilingCommand.END)
- probe.getProfilingInfo(CLEvent.ProfilingCommand.START);
out.println("time: "+time);
assertTrue(time > 0);

events.release();
context.release();

}

@Test
public void concurrencyTest() throws IOException, InterruptedException {

out.println(" - - - QueueBarrier test - - - ");

final int elements = ONE_MB/SIZEOF_INT * 10; // 20MB per buffer
final int elements = ONE_MB / SIZEOF_INT * 10; // 20MB per buffer

CLContext context = CLContext.create();

CLDevice[] devices = context.getCLDevices();

if(devices.length < 2) {
if (devices.length < 2) {
out.println("aborting test... need at least 2 devices");
context.release();
return;
}

final CLBuffer<ByteBuffer> clBufferC = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferD = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferC = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferD = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);

final CLBuffer<ByteBuffer> clBufferA1 = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferB1 = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferA2 = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferB2 = context.createByteBuffer(elements*SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferA1 = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferB1 = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferA2 = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);
final CLBuffer<ByteBuffer> clBufferB2 = context.createByteBuffer(elements * SIZEOF_INT, Mem.READ_ONLY);

CLProgram program = context.createProgram(getClass().getResourceAsStream("testkernels.cl")).build();

final CLKernel vectorAddKernel1 = program.createCLKernel("VectorAddGM")
.setArg(3, elements);

final CLKernel vectorAddKernel2 = program.createCLKernel("VectorAddGM")
.setArg(3, elements);

final CLKernel vectorAddKernel1 = program.createCLKernel("VectorAddGM").setArg(3, elements);
final CLKernel vectorAddKernel2 = program.createCLKernel("VectorAddGM").setArg(3, elements);

int secondDevice = devices.length > 1 ? 1 : 0;

final CLCommandQueue queue1 = devices[0 ].createCommandQueue();
final CLCommandQueue queue2 = devices[secondDevice].createCommandQueue();

if(secondDevice > 0)
System.out.println("using two devices");
if (secondDevice > 0) {
System.out.println("using two devices");
}

final QueueBarrier barrier = new QueueBarrier(2);

Expand All @@ -132,21 +206,20 @@ public void run() {
fillBuffer(clBufferB1.buffer, 67890);

// System.out.println("C buffer");
queue1.putWriteBuffer(clBufferA1, false) // write A
.putWriteBuffer(clBufferB1, true); // write B
queue1.putWriteBuffer(clBufferA1, false) // write A
.putWriteBuffer(clBufferB1, true); // write B

// System.out.println("C args");
vectorAddKernel1.setArgs(clBufferA1, clBufferB1, clBufferC); // C = A+B

// System.out.println("C kernels");
CLEventList events1 = new CLEventList(2);
queue1.put1DRangeKernel(vectorAddKernel1, 0, elements, 256, events1)
queue1.put1DRangeKernel(vectorAddKernel1, 0, elements, groupSize, events1)
.putReadBuffer(clBufferC, false, events1);

barrier.waitFor(queue1, events1);

}

};

Thread thread2 = new Thread("D") {
Expand All @@ -156,10 +229,10 @@ public void run() {

fillBuffer(clBufferA2.buffer, 12345);
fillBuffer(clBufferB2.buffer, 67890);

// System.out.println("D buffer");
queue2.putWriteBuffer(clBufferA2, false) // write A
.putWriteBuffer(clBufferB2, true); // write B
queue2.putWriteBuffer(clBufferA2, false) // write A
.putWriteBuffer(clBufferB2, true); // write B

// System.out.println("D args");
vectorAddKernel2.setArgs(clBufferA2, clBufferB2, clBufferD); // D = A+B
Expand All @@ -172,7 +245,6 @@ public void run() {
barrier.waitFor(queue2, events2);

}

};

out.println("starting threads");
Expand All @@ -185,13 +257,7 @@ public void run() {

context.release();

// vectorAddKernel2.release();

out.println("results are valid");

}




}
}
}
14 changes: 13 additions & 1 deletion test/com/mbien/opencl/CLProgramTest.java
View file
@@ -1,19 +1,30 @@
package com.mbien.opencl;

import com.mbien.opencl.CLProgram.Status;
import java.io.IOException;
import java.util.Map;
import org.junit.Test;

import static org.junit.Assert.*;
import static java.lang.System.*;
import static com.mbien.opencl.CLProgram.CompilerOptions.*;
import static com.mbien.opencl.CLProgram.Status.*;

/**
*
* @author Michael Bien
*/
public class CLProgramTest {

@Test
public void enumsTest() {

// CLProgram enums
for (Status e : Status.values()) {
assertEquals(e, Status.valueOf(e.STATUS));
}
}

@Test
public void rebuildProgramTest() throws IOException {

Expand Down Expand Up @@ -116,7 +127,8 @@ public void programBinariesTest() throws IOException {
assertEquals(program.getSource().length(), 0);

try{
program.createCLKernels();
Map<String, CLKernel> kernels = program.createCLKernels();
fail("expected an exception from createCLKernels but got: "+kernels);
}catch(CLException ex) {
// expected, not build yet
}
Expand Down

0 comments on commit 62d9a63

Please sign in to comment.