You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1302 lines
36 KiB
1302 lines
36 KiB
/*
|
|
* JOCL - Java bindings for OpenCL
|
|
*
|
|
* Copyright 2009 Marco Hutter - http://www.jocl.org/
|
|
*/
|
|
|
|
package com.AI;
|
|
import static org.jocl.CL.*;
|
|
|
|
import org.jocl.*;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.FileReader;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
class Kernel
|
|
{
|
|
private String kernelName;
|
|
private cl_kernel kernel;
|
|
private cl_program program;
|
|
|
|
public String getKernelName() {
|
|
return kernelName;
|
|
}
|
|
|
|
public void setKernelName(String kernelName) {
|
|
this.kernelName = kernelName;
|
|
}
|
|
|
|
public cl_kernel getKernel() {
|
|
return kernel;
|
|
}
|
|
|
|
public void setKernel(cl_kernel kernel) {
|
|
this.kernel = kernel;
|
|
}
|
|
|
|
public cl_program getProgram() {
|
|
return program;
|
|
}
|
|
|
|
public void setProgram(cl_program program) {
|
|
this.program = program;
|
|
}
|
|
}
|
|
|
|
class MyJOCL
|
|
{
|
|
/**
|
|
* The source code of the OpenCL program to execute
|
|
*/
|
|
|
|
private int platformIndex;
|
|
private long deviceType;
|
|
private int deviceIndex;
|
|
private cl_device_id device;
|
|
|
|
private cl_context context;
|
|
private cl_kernel kernel;
|
|
private cl_program program;
|
|
private ArrayList<Kernel> kernelsList;
|
|
private cl_command_queue commandQueue;
|
|
|
|
private cl_mem examplesCharBuffer;
|
|
|
|
private cl_mem nullCharMemObject;
|
|
|
|
private int maxLength;
|
|
private int examplesSize;
|
|
|
|
public cl_context getContext() {
|
|
return context;
|
|
}
|
|
|
|
public void setContext(cl_context context) {
|
|
this.context = context;
|
|
}
|
|
|
|
public int getMaxLength() {
|
|
return maxLength;
|
|
}
|
|
|
|
public void setMaxLength(int maxLength) {
|
|
this.maxLength = maxLength;
|
|
}
|
|
|
|
public int getExamplesSize() {
|
|
return examplesSize;
|
|
}
|
|
|
|
public void setExamplesSize(int examplesSize) {
|
|
this.examplesSize = examplesSize;
|
|
}
|
|
|
|
MyJOCL()
|
|
{
|
|
platformIndex = 0;
|
|
deviceType = CL_DEVICE_TYPE_ALL;
|
|
deviceIndex = 0;
|
|
|
|
kernelsList = new ArrayList<>();
|
|
|
|
// Enable exceptions and subsequently omit error checks in this sample
|
|
CL.setExceptionsEnabled(true);
|
|
|
|
// Obtain the number of platforms
|
|
int[] numPlatformsArray = new int[1];
|
|
clGetPlatformIDs(0, null, numPlatformsArray);
|
|
int numPlatforms = numPlatformsArray[0];
|
|
|
|
// Obtain a platform ID
|
|
cl_platform_id platforms[] = new cl_platform_id[numPlatforms];
|
|
clGetPlatformIDs(platforms.length, platforms, null);
|
|
cl_platform_id platform = platforms[platformIndex];
|
|
|
|
// Initialize the context properties
|
|
cl_context_properties contextProperties = new cl_context_properties();
|
|
contextProperties.addProperty(CL_CONTEXT_PLATFORM, platform);
|
|
|
|
// Obtain the number of devices for the platform
|
|
int numDevicesArray[] = new int[1];
|
|
clGetDeviceIDs(platform, deviceType, 0, null, numDevicesArray);
|
|
int numDevices = numDevicesArray[0];
|
|
|
|
// Obtain a device ID
|
|
cl_device_id devices[] = new cl_device_id[numDevices];
|
|
clGetDeviceIDs(platform, deviceType, numDevices, devices, null);
|
|
device = devices[deviceIndex];
|
|
|
|
// Create a context for the selected device
|
|
context = clCreateContext(
|
|
contextProperties, 1, new cl_device_id[]{device},
|
|
null, null, null);
|
|
|
|
// Create a command-queue for the selected device
|
|
//noinspection deprecation
|
|
commandQueue = clCreateCommandQueue(context, device, 0, null);
|
|
|
|
|
|
|
|
char[] nullChar = new char['\n'];
|
|
|
|
Pointer nullCharPointer = Pointer.to(nullChar);
|
|
|
|
|
|
nullCharMemObject = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * nullChar.length, nullCharPointer, null);
|
|
|
|
setKernels();
|
|
|
|
// Enable exceptions and subsequently omit error checks in this sample
|
|
CL.setExceptionsEnabled(true);
|
|
|
|
// Obtain the number of platforms
|
|
|
|
}
|
|
|
|
void setExamplesCharBuffer(char[] examplesChar)
|
|
{
|
|
Pointer examplesCharPointer = Pointer.to(examplesChar);
|
|
examplesCharBuffer = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * examplesSize * maxLength, examplesCharPointer, null);
|
|
}
|
|
|
|
void setKernels()
|
|
{
|
|
|
|
Kernel kernelTemp = new Kernel();
|
|
String programSource = readFile("SplitDataSet.cl");
|
|
// Create the program from the source code
|
|
program = clCreateProgramWithSource(context,
|
|
1, new String[]{ programSource }, null, null);
|
|
|
|
// Build the program
|
|
clBuildProgram(program, 0, null, null, null, null);
|
|
|
|
// // Create the kernel
|
|
// kernel = clCreateKernel(program, "splitDataSet", null);
|
|
//
|
|
// kernelTemp.setKernelName("splitDataSet");
|
|
// kernelTemp.setKernel(kernel);
|
|
// kernelsList.add(0,kernelTemp);
|
|
|
|
|
|
// programSource = readFile("SumReduction.cl");
|
|
// // Create the program from the source code
|
|
// program = clCreateProgramWithSource(context,
|
|
// 1, new String[]{ programSource }, null, null);
|
|
//
|
|
// // Build the program
|
|
// clBuildProgram(program, 0, null, null, null, null);
|
|
//
|
|
// // Create the kernel
|
|
// kernel = clCreateKernel(program, "sumReduction", null);
|
|
// kernelTemp.setKernelName("sumReduction");
|
|
// kernelTemp.setKernel(kernel);
|
|
// kernelsList.add(1,kernelTemp);
|
|
}
|
|
static boolean isPowerOfTwo(int n)
|
|
{
|
|
return (int)(Math.ceil((Math.log(n) / Math.log(2)))) ==
|
|
(int)(Math.floor(((Math.log(n) / Math.log(2)))));
|
|
}
|
|
|
|
|
|
static int nextPowerOf2(int n)
|
|
{
|
|
int count = 0;
|
|
|
|
// First n in the below
|
|
// condition is for the
|
|
// case where n is 0
|
|
if (n > 0 && (n & (n - 1)) == 0)
|
|
return n;
|
|
|
|
while(n != 0)
|
|
{
|
|
n >>= 1;
|
|
count += 1;
|
|
}
|
|
|
|
return 1 << count;
|
|
}
|
|
|
|
ReturnObj testDataSetParallel(int[] examplesInt, int examplesSize, int maxLength, int cellSpan,
|
|
String attributeName, String value, List<Attribute> attributesList, Attribute targetAttribute)
|
|
{
|
|
// kernel = kernelsList.get(0).getKernel();
|
|
// initCL();
|
|
// Create input- and examplesViInt data
|
|
|
|
|
|
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesChar[i * maxLength + j]);
|
|
// if(examplesChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.print("Examples char = " + Arrays.toString(examplesChar));
|
|
// System.out.print(new String(examplesChar));
|
|
|
|
Attribute attribute = new Attribute();
|
|
|
|
if(attributeName.equals(targetAttribute.getAttributeName()))
|
|
attribute = targetAttribute;
|
|
else {
|
|
|
|
for (Attribute a : attributesList) {
|
|
if (a.getAttributeName().equalsIgnoreCase(attributeName))
|
|
attribute = a;
|
|
}
|
|
}
|
|
int attributeIndex = attribute.getAttributeIndex();
|
|
// System.out.println("Index = " + attributeIndex);
|
|
|
|
// attribute.setAttributeName("Play");
|
|
// attribute.addToValuesSet("Yes");
|
|
// attribute.addToValuesSet("No");
|
|
// String value = attribute.getValuesSet().
|
|
|
|
cl_mem[] memObjects = new cl_mem[5];
|
|
|
|
|
|
|
|
// System.out.println("For attribute: " + attribute.getAttributeName());
|
|
// char[] examplesViChar = new char[examplesSize * maxLength];
|
|
|
|
String s = value;
|
|
|
|
// System.out.println("For value: " + s);
|
|
// String combined = attribute.getAttributeName() + " " + s;
|
|
char[] pattern = s.toCharArray();
|
|
// System.out.println(combined);
|
|
// System.out.print("Pattern = " + Arrays.toString(pattern));
|
|
// System.out.println();
|
|
|
|
|
|
int[] examplesViInt = new int[examplesSize];
|
|
// for(int i = 0; i< examplesSize; i++)
|
|
// {
|
|
// examplesViInt[i] = 0;
|
|
// }
|
|
|
|
|
|
Pointer examplesIntPointer = Pointer.to(examplesInt);
|
|
Pointer patternPointer = Pointer.to(pattern);
|
|
Pointer examplesViIntPointer = Pointer.to(examplesViInt);
|
|
// Pointer examplesViCharPointer = Pointer.to(examplesViChar);
|
|
|
|
// The platform, device type and device number
|
|
// that will be used
|
|
|
|
|
|
// Allocate the memory objects for the input- and examplesViInt data
|
|
|
|
// System.out.println("Pattern size bytes = " + Sizeof.cl_char);
|
|
|
|
memObjects[1] = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
|
|
memObjects[2] = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * pattern.length, patternPointer, null);
|
|
// memObjects[4] = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
// Sizeof.cl_char2 * nullChar.length, nullCharPointer, null);
|
|
|
|
cl_mem examplesIntBuffer = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_int*examplesSize, examplesIntPointer, null);
|
|
kernel = clCreateKernel(program, "splitDataSet3", null);
|
|
|
|
// __kernel void splitDataSet3(__global char *examplesChar, __global int* examplesInt,
|
|
// const int rowSpan, const int cellSpan, const int index, __global char *pat,
|
|
// const int pat_length, __global int* examplesViInt)
|
|
// Set the arguments for the kernel
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(examplesCharBuffer));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(examplesIntBuffer));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_int, Pointer.to(new int[]{maxLength * 2}));
|
|
clSetKernelArg(kernel, 3,
|
|
Sizeof.cl_int, Pointer.to(new int[]{cellSpan * 2}));
|
|
clSetKernelArg(kernel, 4,
|
|
Sizeof.cl_int, Pointer.to(new int[]{attributeIndex}));
|
|
clSetKernelArg(kernel, 5,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[2]));
|
|
clSetKernelArg(kernel, 6,
|
|
Sizeof.cl_int, Pointer.to(new int[]{pattern.length * Sizeof.cl_char2}));
|
|
clSetKernelArg(kernel, 7,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[1]));
|
|
|
|
// Set the work-item dimensions
|
|
long[] global_work_size = new long[]{examplesSize};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
cl_event event = new cl_event();
|
|
// Execute the kernel
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, event);
|
|
|
|
clWaitForEvents(1,new cl_event[]{event});
|
|
|
|
// System.out.println(Arrays.toString(examplesViInt));
|
|
|
|
// Read the examplesViInt data
|
|
clEnqueueReadBuffer(commandQueue, memObjects[1], CL_TRUE, 0,
|
|
examplesSize * Sizeof.cl_int, examplesViIntPointer, 0, null, null);
|
|
|
|
int size = reduceArray(examplesViInt);
|
|
|
|
ReturnObj returnObj = new ReturnObj();
|
|
returnObj.setExamplesInt(examplesViInt);
|
|
returnObj.setSize(size);
|
|
// System.out.println("Size = " + size);
|
|
|
|
// sumReduction2(examplesViInt.length, examplesViInt);
|
|
|
|
// System.out.println(Arrays.toString(examplesViInt));
|
|
//
|
|
// clEnqueueReadBuffer(commandQueue,memObjects[3], CL_TRUE,0,
|
|
// Sizeof.cl_char2 * examplesSize *maxLength,
|
|
// examplesViCharPointer,0,null,null);
|
|
// System.out.println(Arrays.toString(examplesViChar));
|
|
|
|
|
|
// int maskSize = 0;
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViInt[i] == 1)
|
|
// maskSize++;
|
|
// }
|
|
// System.out.println("Mask size is: " + maskSize);
|
|
// int j = 0;
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViInt[i] == 1)
|
|
// {
|
|
// System.arraycopy(examplesChar,i*maxLength,examplesViChar,j*maxLength,maxLength);
|
|
//
|
|
//// System.out.println();
|
|
// j++;
|
|
// }
|
|
// if(j==maskSize)
|
|
// break;
|
|
// }
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViChar[i*maxLength] == '\0')
|
|
// {
|
|
// System.out.println("No data here");
|
|
// continue;
|
|
// }
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesViChar[i * maxLength + j]);
|
|
//
|
|
// if(examplesViChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.println();
|
|
// Release kernel, program, and memory objects
|
|
|
|
clReleaseMemObject(memObjects[1]);
|
|
clReleaseMemObject(memObjects[2]);
|
|
return returnObj;
|
|
// clReleaseMemObject(memObjects[3]);
|
|
|
|
|
|
|
|
// clReleaseMemObject(memObjects[0]);
|
|
|
|
|
|
|
|
}
|
|
|
|
ReturnObj testDataSetParallel2(int[] examplesInt, int examplesSize, int maxLength, int cellSpan,
|
|
String attributeName, String value, List<Attribute> attributesList, Attribute targetAttribute)
|
|
{
|
|
// kernel = kernelsList.get(0).getKernel();
|
|
// initCL();
|
|
// Create input- and examplesViInt data
|
|
|
|
|
|
|
|
int[] yesArray = new int[examplesSize];
|
|
int[] noArray = new int[examplesSize];
|
|
|
|
char[] yes = "Yes".toCharArray();
|
|
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesChar[i * maxLength + j]);
|
|
// if(examplesChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.print("Examples char = " + Arrays.toString(examplesChar));
|
|
// System.out.print(new String(examplesChar));
|
|
|
|
Attribute attribute = new Attribute();
|
|
|
|
|
|
|
|
for (Attribute a : attributesList) {
|
|
if (a.getAttributeName().equalsIgnoreCase(attributeName))
|
|
attribute = a;
|
|
}
|
|
|
|
int attributeIndex = attribute.getAttributeIndex();
|
|
// System.out.println("Index = " + attributeIndex);
|
|
|
|
// attribute.setAttributeName("Play");
|
|
// attribute.addToValuesSet("Yes");
|
|
// attribute.addToValuesSet("No");
|
|
// String value = attribute.getValuesSet().
|
|
|
|
cl_mem[] memObjects = new cl_mem[5];
|
|
|
|
|
|
|
|
// System.out.println("For attribute: " + attribute.getAttributeName());
|
|
//// char[] examplesViChar = new char[examplesSize * maxLength];
|
|
//
|
|
// System.out.println("For value: " + value);
|
|
// String combined = attribute.getAttributeName() + " " + s;
|
|
char[] pattern = value.toCharArray();
|
|
// System.out.println(combined);
|
|
// System.out.print("Pattern = " + Arrays.toString(pattern));
|
|
// System.out.println();
|
|
|
|
|
|
// int[] examplesViInt = new int[examplesSize];
|
|
// for(int i = 0; i< examplesSize; i++)
|
|
// {
|
|
// examplesViInt[i] = 0;
|
|
// }
|
|
|
|
|
|
Pointer examplesIntPointer = Pointer.to(examplesInt);
|
|
Pointer patternPointer = Pointer.to(pattern);
|
|
// Pointer examplesViIntPointer = Pointer.to(examplesViInt);
|
|
Pointer yesArrayPointer = Pointer.to(yesArray);
|
|
Pointer noArrayPointer = Pointer.to(noArray);
|
|
Pointer yesPointer = Pointer.to(yes);
|
|
// Pointer examplesViCharPointer = Pointer.to(examplesViChar);
|
|
|
|
// The platform, device type and device number
|
|
// that will be used
|
|
|
|
|
|
// Allocate the memory objects for the input- and examplesViInt data
|
|
|
|
// System.out.println("Pattern size bytes = " + Sizeof.cl_char);
|
|
|
|
// memObjects[1] = clCreateBuffer(context,
|
|
// CL_MEM_WRITE_ONLY ,
|
|
// Sizeof.cl_int * examplesSize,null, null);
|
|
|
|
|
|
memObjects[2] = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * pattern.length, patternPointer, null);
|
|
// memObjects[4] = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
// Sizeof.cl_char2 * nullChar.length, nullCharPointer, null);
|
|
|
|
cl_mem yesArrayMemObject = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
cl_mem noArrayMemObject = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
cl_mem yesMemObject = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_char2 * yes.length ,yesPointer, null);
|
|
|
|
cl_mem examplesIntBuffer = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_int*examplesSize, examplesIntPointer, null);
|
|
kernel = clCreateKernel(program, "splitDataSet4", null);
|
|
|
|
// __kernel void splitDataSet4(__global char *examplesChar, __global int* examplesInt,
|
|
// const int rowSpan, const int cellSpan, const int index, __global char *pat,
|
|
// const int pat_length,
|
|
// __global char* yes, __global int* yesArray,
|
|
// __global int* noArray, int targetIndex)
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(examplesCharBuffer));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(examplesIntBuffer));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_int, Pointer.to(new int[]{maxLength * 2}));
|
|
clSetKernelArg(kernel, 3,
|
|
Sizeof.cl_int, Pointer.to(new int[]{cellSpan * 2}));
|
|
clSetKernelArg(kernel, 4,
|
|
Sizeof.cl_int, Pointer.to(new int[]{attributeIndex}));
|
|
clSetKernelArg(kernel, 5,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[2]));
|
|
clSetKernelArg(kernel, 6,
|
|
Sizeof.cl_int, Pointer.to(new int[]{pattern.length * Sizeof.cl_char2}));
|
|
// clSetKernelArg(kernel, 7,
|
|
// Sizeof.cl_mem, Pointer.to(memObjects[1]));
|
|
clSetKernelArg(kernel, 7,
|
|
Sizeof.cl_mem, Pointer.to(yesMemObject));
|
|
clSetKernelArg(kernel, 8,
|
|
Sizeof.cl_mem, Pointer.to(yesArrayMemObject));
|
|
clSetKernelArg(kernel, 9,
|
|
Sizeof.cl_mem, Pointer.to(noArrayMemObject));
|
|
clSetKernelArg(kernel, 10,
|
|
Sizeof.cl_int, Pointer.to(new int[]{targetAttribute.getAttributeIndex()}));
|
|
|
|
// Set the work-item dimensions
|
|
long[] global_work_size = new long[]{examplesSize};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
cl_event event = new cl_event();
|
|
// Execute the kernel
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, event);
|
|
|
|
clWaitForEvents(1,new cl_event[]{event});
|
|
|
|
// System.out.println(Arrays.toString(examplesViInt));
|
|
|
|
// Read the examplesViInt data
|
|
// clEnqueueReadBuffer(commandQueue, memObjects[1], CL_TRUE, 0,
|
|
// examplesSize * Sizeof.cl_int, examplesViIntPointer, 0, null, null);
|
|
|
|
// int size = reduceArray(examplesViInt);
|
|
|
|
ReturnObj returnObj = new ReturnObj();
|
|
|
|
// sumReduction2(examplesViInt.length, examplesViInt);
|
|
|
|
// System.out.println(Arrays.toString(examplesViInt));
|
|
//
|
|
clEnqueueReadBuffer(commandQueue,yesArrayMemObject, CL_TRUE,0,
|
|
Sizeof.cl_int * examplesSize,
|
|
yesArrayPointer,0,null,null);
|
|
// System.out.println(Arrays.toString(yesArray));
|
|
clEnqueueReadBuffer(commandQueue,noArrayMemObject, CL_TRUE,0,
|
|
Sizeof.cl_int * examplesSize,
|
|
noArrayPointer,0,null,null);
|
|
// System.out.println(Arrays.toString(noArray));
|
|
|
|
returnObj.setYesCount(reduceArray(yesArray));
|
|
returnObj.setNoCount(reduceArray(noArray));
|
|
|
|
// int maskSize = 0;
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViInt[i] == 1)
|
|
// maskSize++;
|
|
// }
|
|
// System.out.println("Mask size is: " + maskSize);
|
|
// int j = 0;
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViInt[i] == 1)
|
|
// {
|
|
// System.arraycopy(examplesChar,i*maxLength,examplesViChar,j*maxLength,maxLength);
|
|
//
|
|
//// System.out.println();
|
|
// j++;
|
|
// }
|
|
// if(j==maskSize)
|
|
// break;
|
|
// }
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViChar[i*maxLength] == '\0')
|
|
// {
|
|
// System.out.println("No data here");
|
|
// continue;
|
|
// }
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesViChar[i * maxLength + j]);
|
|
//
|
|
// if(examplesViChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.println();
|
|
// Release kernel, program, and memory objects
|
|
|
|
// clReleaseMemObject(memObjects[1]);
|
|
clReleaseMemObject(memObjects[2]);
|
|
clReleaseMemObject(examplesIntBuffer);
|
|
clReleaseMemObject(yesArrayMemObject);
|
|
clReleaseMemObject(noArrayMemObject);
|
|
return returnObj;
|
|
// clReleaseMemObject(memObjects[3]);
|
|
|
|
|
|
|
|
// clReleaseMemObject(memObjects[0]);
|
|
|
|
|
|
|
|
}
|
|
|
|
int reduceArray(int[] array)
|
|
{
|
|
int sum = 0;
|
|
for (int value : array) {
|
|
sum += value;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
int getCount(int[] examplesInt, int examplesSize, int maxLength, String value, int cellSpan,
|
|
Attribute targetAttribute)
|
|
{
|
|
// kernel = kernelsList.get(0).getKernel();
|
|
// initCL();
|
|
// Create input- and countArray data
|
|
|
|
|
|
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesChar[i * maxLength + j]);
|
|
// if(examplesChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.print("Examples char = " + Arrays.toString(examplesChar));
|
|
// System.out.print(new String(examplesChar));
|
|
|
|
|
|
int attributeIndex = targetAttribute.getAttributeIndex();
|
|
// System.out.println("Index = " + attributeIndex);
|
|
|
|
// attribute.setAttributeName("Play");
|
|
// attribute.addToValuesSet("Yes");
|
|
// attribute.addToValuesSet("No");
|
|
// String value = attribute.getValuesSet().
|
|
|
|
cl_mem[] memObjects = new cl_mem[5];
|
|
|
|
|
|
|
|
// System.out.println("For attribute: " + targetAttribute.getAttributeName());
|
|
// char[] examplesViChar = new char[examplesSize * maxLength];
|
|
|
|
// System.out.println("For value: " + value);
|
|
// String combined = attribute.getAttributeName() + " " + s;
|
|
char[] pattern = value.toCharArray();
|
|
// System.out.println(combined);
|
|
// System.out.print("Pattern = " + Arrays.toString(pattern));
|
|
// System.out.println();
|
|
|
|
int[] countArray = new int[examplesSize];
|
|
// for(int i = 0; i< examplesSize; i++)
|
|
// {
|
|
// countArray[i] = 0;
|
|
// }
|
|
|
|
|
|
Pointer examplesIntPointer = Pointer.to(examplesInt);
|
|
Pointer patternPointer = Pointer.to(pattern);
|
|
Pointer countArrayPointer = Pointer.to(countArray);
|
|
// Pointer examplesViCharPointer = Pointer.to(examplesViChar);
|
|
|
|
// The platform, device type and device number
|
|
// that will be used
|
|
|
|
|
|
// Allocate the memory objects for the input- and countArray data
|
|
|
|
// System.out.println("Pattern size bytes = " + Sizeof.cl_char);
|
|
|
|
memObjects[1] = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
|
|
memObjects[2] = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * pattern.length, patternPointer, null);
|
|
// memObjects[4] = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
// Sizeof.cl_char2 * nullChar.length, nullCharPointer, null);
|
|
|
|
cl_mem examplesIntBuffer = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_int*examplesSize, examplesIntPointer, null);
|
|
kernel = clCreateKernel(program, "getCount", null);
|
|
|
|
// __kernel void splitDataSet3(__global char *examplesChar, __global int* examplesInt,
|
|
// const int rowSpan, const int cellSpan, const int index, __global char *pat,
|
|
// const int pat_length, __global int* countArray)
|
|
// Set the arguments for the kernel
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(examplesCharBuffer));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(examplesIntBuffer));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_int, Pointer.to(new int[]{maxLength * 2}));
|
|
clSetKernelArg(kernel, 3,
|
|
Sizeof.cl_int, Pointer.to(new int[]{cellSpan * 2}));
|
|
clSetKernelArg(kernel, 4,
|
|
Sizeof.cl_int, Pointer.to(new int[]{attributeIndex}));
|
|
clSetKernelArg(kernel, 5,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[2]));
|
|
clSetKernelArg(kernel, 6,
|
|
Sizeof.cl_int, Pointer.to(new int[]{pattern.length * Sizeof.cl_char2}));
|
|
clSetKernelArg(kernel, 7,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[1]));
|
|
|
|
// Set the work-item dimensions
|
|
long[] global_work_size = new long[]{examplesSize};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
// Execute the kernel
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, null);
|
|
|
|
// System.out.println(Arrays.toString(countArray));
|
|
|
|
// Read the countArray data
|
|
clEnqueueReadBuffer(commandQueue, memObjects[1], CL_TRUE, 0,
|
|
examplesSize * Sizeof.cl_int, countArrayPointer, 0, null, null);
|
|
|
|
int count = reduceArray(countArray);
|
|
|
|
// sumReduction2(countArray.length, countArray);
|
|
|
|
|
|
// System.out.println(Arrays.toString(countArray));
|
|
//
|
|
// clEnqueueReadBuffer(commandQueue,memObjects[3], CL_TRUE,0,
|
|
// Sizeof.cl_char2 * examplesSize *maxLength,
|
|
// examplesViCharPointer,0,null,null);
|
|
// System.out.println(Arrays.toString(examplesViChar));
|
|
|
|
|
|
// int maskSize = 0;
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(countArray[i] == 1)
|
|
// maskSize++;
|
|
// }
|
|
// System.out.println("Mask size is: " + maskSize);
|
|
// int j = 0;
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(countArray[i] == 1)
|
|
// {
|
|
// System.arraycopy(examplesChar,i*maxLength,examplesViChar,j*maxLength,maxLength);
|
|
//
|
|
//// System.out.println();
|
|
// j++;
|
|
// }
|
|
// if(j==maskSize)
|
|
// break;
|
|
// }
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViChar[i*maxLength] == '\0')
|
|
// {
|
|
// System.out.println("No data here");
|
|
// continue;
|
|
// }
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesViChar[i * maxLength + j]);
|
|
//
|
|
// if(examplesViChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.println();
|
|
// Release kernel, program, and memory objects
|
|
|
|
clReleaseMemObject(memObjects[1]);
|
|
clReleaseMemObject(memObjects[2]);
|
|
// clReleaseMemObject(memObjects[3]);
|
|
|
|
|
|
|
|
// clReleaseMemObject(memObjects[0]);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
void splitDataSetParallel(char[] examplesChar, int examplesSize, int maxLength,
|
|
String attributeName, String value, ArrayList<Attribute> attributesList)
|
|
{
|
|
// if(!MyJOCL.isPowerOfTwo(examplesSize))
|
|
// examplesSize = MyJOCL.nextPowerOf2(examplesSize);
|
|
// System.out.println("Examples size power of 2 is: " + examplesSize);
|
|
// kernel = kernelsList.get(0).getKernel();
|
|
// initCL();
|
|
// Create input- and output data
|
|
|
|
|
|
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesChar[i * maxLength + j]);
|
|
// if(examplesChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.print("Examples char = " + Arrays.toString(examplesChar));
|
|
// System.out.print(new String(examplesChar));
|
|
|
|
|
|
Attribute attribute = new Attribute();
|
|
for (Attribute a : attributesList) {
|
|
if (a.getAttributeName().equalsIgnoreCase(attributeName))
|
|
attribute = a;
|
|
}
|
|
char[] nullChar = new char['\n'];
|
|
|
|
// attribute.setAttributeName("Play");
|
|
// attribute.addToValuesSet("Yes");
|
|
// attribute.addToValuesSet("No");
|
|
// String value = attribute.getValuesSet().
|
|
|
|
Pointer examplesCharPointer = Pointer.to(examplesChar);
|
|
// Pointer nullCharPointer = Pointer.to(nullChar);
|
|
|
|
cl_mem[] memObjects = new cl_mem[5];
|
|
// memObjects[0] = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
// Sizeof.cl_char * examplesSize * maxLength * 2, examplesCharPointer, null);
|
|
|
|
|
|
|
|
|
|
System.out.println("For attribute: " + attribute.getAttributeName());
|
|
String s = value;
|
|
char[] examplesViChar = new char[examplesSize * maxLength];
|
|
|
|
System.out.println("For value: " + s);
|
|
String combined = attribute.getAttributeName() + " " + s;
|
|
char[] pattern = combined.toCharArray();
|
|
System.out.println(combined);
|
|
System.out.print("Pattern = " + Arrays.toString(pattern));
|
|
System.out.println();
|
|
|
|
int[] output = new int[examplesSize];
|
|
// for(int i = 0; i< examplesSize; i++)
|
|
// {
|
|
// output[i] = 0;
|
|
// }
|
|
|
|
|
|
Pointer patternPointer = Pointer.to(pattern);
|
|
Pointer outputPointer = Pointer.to(output);
|
|
Pointer examplesViCharPointer = Pointer.to(examplesViChar);
|
|
|
|
// The platform, device type and device number
|
|
// that will be used
|
|
|
|
|
|
// Allocate the memory objects for the input- and output data
|
|
|
|
// System.out.println("Pattern size bytes = " + Sizeof.cl_char);
|
|
|
|
memObjects[1] = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
|
|
memObjects[2] = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
Sizeof.cl_char2 * pattern.length, patternPointer, null);
|
|
memObjects[3] = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY,
|
|
Sizeof.cl_char2 * examplesSize *maxLength, null, null);
|
|
// memObjects[4] = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
|
|
// Sizeof.cl_char2 * nullChar.length, nullCharPointer, null);
|
|
|
|
kernel = clCreateKernel(program, "splitDataSet", null);
|
|
|
|
|
|
// Set the arguments for the kernel
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(examplesCharBuffer));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[1]));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_int, Pointer.to(new int[]{maxLength * 2}));
|
|
clSetKernelArg(kernel, 3,
|
|
Sizeof.cl_int, Pointer.to(new int[]{examplesSize}));
|
|
clSetKernelArg(kernel, 4,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[2]));
|
|
clSetKernelArg(kernel, 5,
|
|
Sizeof.cl_int, Pointer.to(new int[]{pattern.length * Sizeof.cl_char2}));
|
|
clSetKernelArg(kernel,6,
|
|
Sizeof.cl_mem, Pointer.to(memObjects[3]));
|
|
clSetKernelArg(kernel, 7,
|
|
Sizeof.cl_int, Pointer.to(nullCharMemObject));
|
|
|
|
// Set the work-item dimensions
|
|
long[] global_work_size = new long[]{examplesSize};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
// Execute the kernel
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, null);
|
|
|
|
// System.out.println(Arrays.toString(output));
|
|
|
|
// Read the output data
|
|
// clEnqueueReadBuffer(commandQueue, memObjects[1], CL_TRUE, 0,
|
|
// examplesSize * Sizeof.cl_int, outputPointer, 0, null, null);
|
|
|
|
// sumReduction2(output.length,output);
|
|
|
|
// System.out.println(Arrays.toString(output));
|
|
|
|
// clEnqueueReadBuffer(commandQueue,memObjects[3], CL_TRUE,0,
|
|
// Sizeof.cl_char2 * examplesSize *maxLength,
|
|
// examplesViCharPointer,0,null,null);
|
|
// System.out.println(Arrays.toString(examplesViChar));
|
|
|
|
|
|
// int maskSize = 0;
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(output[i] == 1)
|
|
// maskSize++;
|
|
// }
|
|
// System.out.println("Mask size is: " + maskSize);
|
|
// int j = 0;
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(output[i] == 1)
|
|
// {
|
|
// System.arraycopy(examplesChar,i*maxLength,examplesViChar,j*maxLength,maxLength);
|
|
//
|
|
//// System.out.println();
|
|
// j++;
|
|
// }
|
|
// if(j==maskSize)
|
|
// break;
|
|
// }
|
|
//
|
|
// for(int i=0;i<examplesSize;i++)
|
|
// {
|
|
// if(examplesViChar[i*maxLength] == '\0')
|
|
// {
|
|
// System.out.println("No data here");
|
|
// continue;
|
|
// }
|
|
// for(int j=0;j<maxLength;j++)
|
|
// {
|
|
// System.out.print(examplesViChar[i * maxLength + j]);
|
|
//
|
|
// if(examplesViChar[i*maxLength+j] == '\n')
|
|
// break;
|
|
// }
|
|
//
|
|
// }
|
|
|
|
// System.out.println();
|
|
// Release kernel, program, and memory objects
|
|
|
|
clReleaseMemObject(memObjects[1]);
|
|
clReleaseMemObject(memObjects[2]);
|
|
clReleaseMemObject(memObjects[3]);
|
|
|
|
|
|
// clReleaseMemObject(memObjects[0]);
|
|
}
|
|
|
|
void allOneValues(char[] examples, int examplesSize)
|
|
{
|
|
kernel = clCreateKernel(program, "allOneValues", null);
|
|
|
|
int[] yesArray = new int[examplesSize];
|
|
int[] noArray = new int[examplesSize];
|
|
|
|
char[] yes = "Play Yes".toCharArray();
|
|
char[] no = new char[]{'N','o'};
|
|
|
|
// Pointer srcPointer = Pointer.to(examples);
|
|
Pointer yesArrayPointer = Pointer.to(yesArray);
|
|
Pointer noArrayPointer = Pointer.to(noArray);
|
|
Pointer yesPointer = Pointer.to(yes);
|
|
Pointer noPointer = Pointer.to(no);
|
|
|
|
// cl_mem srcMemObject = clCreateBuffer(context,
|
|
// CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,
|
|
// Sizeof.cl_char2 * examples.length,srcPointer, null);
|
|
cl_mem yesArrayMemObject = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
cl_mem noArrayMemObject = clCreateBuffer(context,
|
|
CL_MEM_WRITE_ONLY ,
|
|
Sizeof.cl_int * examplesSize,null, null);
|
|
cl_mem yesMemObject = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_char2 * yes.length ,yesPointer, null);
|
|
cl_mem noMemObject = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_char2 * no.length,noPointer, null);
|
|
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(examplesCharBuffer));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(yesArrayMemObject));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_mem, Pointer.to(noArrayMemObject));
|
|
clSetKernelArg(kernel, 3,
|
|
Sizeof.cl_int, Pointer.to(new int[]{80 * 2}));
|
|
clSetKernelArg(kernel, 4,
|
|
Sizeof.cl_mem, Pointer.to(yesMemObject));
|
|
clSetKernelArg(kernel, 5,
|
|
Sizeof.cl_mem, Pointer.to(noMemObject));
|
|
clSetKernelArg(kernel, 6,
|
|
Sizeof.cl_mem, Pointer.to(nullCharMemObject));
|
|
|
|
long[] global_work_size = new long[]{examplesSize};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, null);
|
|
|
|
clEnqueueReadBuffer(commandQueue, yesArrayMemObject, CL_TRUE, 0,
|
|
Sizeof.cl_int * examplesSize, yesArrayPointer, 0, null, null);
|
|
clEnqueueReadBuffer(commandQueue, noArrayMemObject, CL_TRUE, 0,
|
|
Sizeof.cl_int * examplesSize, noArrayPointer, 0, null, null);
|
|
|
|
System.out.println(Arrays.toString(yesArray));
|
|
System.out.println(Arrays.toString(noArray));
|
|
|
|
|
|
|
|
}
|
|
|
|
void sumReduction()
|
|
{
|
|
kernel = clCreateKernel(program, "sumReduction", null);
|
|
int ARRAYSIZE = 10;
|
|
|
|
|
|
if(!isPowerOfTwo(ARRAYSIZE))
|
|
ARRAYSIZE = nextPowerOf2(ARRAYSIZE);
|
|
|
|
|
|
int[] testArray = new int[ARRAYSIZE];
|
|
int[] destArray = new int[ARRAYSIZE/4];
|
|
for(int i=0;i<ARRAYSIZE;i++)
|
|
{
|
|
testArray[i]=1;
|
|
}
|
|
|
|
System.out.println(Arrays.toString(testArray));
|
|
|
|
Pointer srcArrayPointer = Pointer.to(testArray);
|
|
Pointer dstArrayPointer = Pointer.to(destArray);
|
|
|
|
cl_mem srcArray = clCreateBuffer(context,
|
|
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_int * testArray.length,srcArrayPointer, null);
|
|
cl_mem dstArray = clCreateBuffer(context,
|
|
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_int * destArray.length,dstArrayPointer, null);
|
|
|
|
long[] global_work_size = new long[]{ARRAYSIZE / 4};
|
|
long[] local_work_size = new long[]{1};
|
|
|
|
clSetKernelArg(kernel, 0,
|
|
Sizeof.cl_mem, Pointer.to(srcArray));
|
|
clSetKernelArg(kernel, 1,
|
|
Sizeof.cl_mem, Pointer.to(dstArray));
|
|
clSetKernelArg(kernel, 2,
|
|
Sizeof.cl_int, Pointer.to(new int[]{4}));
|
|
|
|
// while len(a)>=offset:
|
|
// c = np.zeros(np.int32(len(a)/offset), dtype=cl.cltypes.uint)
|
|
// a_dev = cl.Buffer(ctx, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=a)
|
|
// c_dev = cl.Buffer(ctx, cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, hostbuf=c)
|
|
// event = prg.summation(queue, (np.int32(len(a)/offset),),None, a_dev,c_dev, np.uint32(offset))
|
|
// event.wait()
|
|
// cl.enqueue_copy(queue, c, c_dev)
|
|
// print(c)
|
|
// a = c
|
|
// print("Length of a = {}".format(len(a)))
|
|
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null,
|
|
global_work_size, local_work_size, 0, null, null);
|
|
|
|
System.out.println(Arrays.toString(destArray));
|
|
|
|
clEnqueueReadBuffer(commandQueue, dstArray, CL_TRUE, 0,
|
|
Sizeof.cl_int * destArray.length, dstArrayPointer, 0, null, null);
|
|
|
|
System.out.println(Arrays.toString(destArray));
|
|
|
|
clReleaseMemObject(srcArray);
|
|
clReleaseMemObject(dstArray);
|
|
|
|
|
|
}
|
|
|
|
void sumReduction2(int ARRAYSIZE, int[] testArray)
|
|
{
|
|
kernel = clCreateKernel(program, "foldKernel", null);
|
|
// int ARRAYSIZE = 10;
|
|
|
|
|
|
if(!isPowerOfTwo(ARRAYSIZE))
|
|
ARRAYSIZE = nextPowerOf2(ARRAYSIZE);
|
|
|
|
|
|
// int[] testArray = new int[ARRAYSIZE];
|
|
// for(int i=0;i<ARRAYSIZE;i++)
|
|
// {
|
|
// if(i%2 == 0)
|
|
// testArray[i]=1;
|
|
// }
|
|
// int[] destArray = testArray;
|
|
|
|
Pointer srcArrayPointer = Pointer.to(testArray);
|
|
|
|
|
|
cl_mem srcArray = clCreateBuffer(context,
|
|
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR ,
|
|
Sizeof.cl_int * testArray.length,srcArrayPointer, null);
|
|
|
|
// long[] global_work_size = new long[]{ARRAYSIZE};
|
|
// long[] local_work_size = new long[]{1};
|
|
|
|
System.out.println(Arrays.toString(testArray));
|
|
|
|
|
|
int t = ARRAYSIZE;
|
|
while (t > 1) {
|
|
int m = t / 2;
|
|
int n = (t + 1) / 2;
|
|
clSetKernelArg(kernel, 0, Sizeof.cl_mem, Pointer.to(srcArray));
|
|
clSetKernelArg(kernel, 1, Sizeof.cl_int, Pointer.to(new int[]{n}));
|
|
cl_event evFold = new cl_event();
|
|
clEnqueueNDRangeKernel(commandQueue, kernel, 1, null, new long[]{m}, null, 0, null, evFold);
|
|
clWaitForEvents(1, new cl_event[]{evFold});
|
|
t = n;
|
|
}
|
|
|
|
|
|
// while len(a)>=offset:
|
|
// c = np.zeros(np.int32(len(a)/offset), dtype=cl.cltypes.uint)
|
|
// a_dev = cl.Buffer(ctx, cl.mem_flags.READ_ONLY | cl.mem_flags.COPY_HOST_PTR, hostbuf=a)
|
|
// c_dev = cl.Buffer(ctx, cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, hostbuf=c)
|
|
// event = prg.summation(queue, (np.int32(len(a)/offset),),None, a_dev,c_dev, np.uint32(offset))
|
|
// event.wait()
|
|
// cl.enqueue_copy(queue, c, c_dev)
|
|
// print(c)
|
|
// a = c
|
|
// print("Length of a = {}".format(len(a)))
|
|
|
|
|
|
|
|
|
|
clEnqueueReadBuffer(commandQueue, srcArray, CL_TRUE, 0,
|
|
Sizeof.cl_int * testArray.length, srcArrayPointer, 0, null, null);
|
|
|
|
System.out.println("After " + Arrays.toString(testArray));
|
|
|
|
clReleaseMemObject(srcArray);
|
|
}
|
|
|
|
|
|
void initCL()
|
|
{
|
|
|
|
}
|
|
|
|
void endCL()
|
|
{
|
|
clReleaseMemObject(examplesCharBuffer);
|
|
clReleaseKernel(kernel);
|
|
clReleaseProgram(program);
|
|
clReleaseCommandQueue(commandQueue);
|
|
clReleaseContext(context);
|
|
}
|
|
private static String readFile(String fileName)
|
|
{
|
|
BufferedReader bufferedReader = null;
|
|
try
|
|
{
|
|
bufferedReader = new BufferedReader(new FileReader(fileName));
|
|
StringBuilder sb = new StringBuilder();
|
|
String line;
|
|
while (true)
|
|
{
|
|
line = bufferedReader.readLine();
|
|
if (line == null)
|
|
{
|
|
break;
|
|
}
|
|
sb.append(line).append("\n");
|
|
}
|
|
return sb.toString();
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
e.printStackTrace();
|
|
return "";
|
|
}
|
|
finally
|
|
{
|
|
if (bufferedReader != null)
|
|
{
|
|
try
|
|
{
|
|
bufferedReader.close();
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
ex.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|