Java JavaCL.createBestContext方法代码示例

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
@Before
public void setUp() throws ProgramBuildException {
	// Set up context and queue
	context = JavaCL.createBestContext();
	queue = context.createDefaultQueue();
	// Build program
	ProgramBuilder pb = new ProgramBuilder("sha256.cl", "krist_miner.cl", "test_kernels.cl");
	pb.addBuildOption("-Werror");
	pb.defineMacro("UNIT_TESTING", 1);
	program = pb.build(context);
	// Test that CL code can be compiled and the testCompile kernel can be
	// run without errors
	CLKernel kernel = program.createKernel("testCompile");
	CLEvent compilationTest = kernel.enqueueNDRange(queue, new int[] { 1 });
	compilationTest.waitFor();
}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
@Before
public void setUp() {
	context = JavaCL.createBestContext();
	queue = context.createDefaultQueue();
	String mainCode = CLCodeLoader.loadCode("/sha256.cl");
	String minerCode = CLCodeLoader.loadCode("/krist_miner.cl");
	String testCode = CLCodeLoader.loadCode("/test_kernels.cl");
	assertNotNull("Failed to load main code", mainCode);
	assertNotNull("Failed to load miner code", minerCode);
	assertNotNull("Failed to load test code", testCode);
	program = context.createProgram("#define UNIT_TESTING\n",mainCode, minerCode, testCode);
	
	// Treat all warning as errors so
	// tests will fail if warnings occur
	program.addBuildOption("-Werror");
	
	// Add other build options
	for (String opt : JCLMiner.cl_build_options) {
		program.addBuildOption(opt);
	}
	
	// Test that CL code can be compiled and the testCompile kernel can be run
	CLKernel kernel = program.createKernel("testCompile");
	CLEvent compilationTest = kernel.enqueueNDRange(queue, new int[] {1});
	compilationTest.waitFor();
}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
public static Pointer<Float> add(Pointer<Float> a, Pointer<Float> b)
			throws CLBuildException {
		int n = (int) a.getValidElements();

		CLContext context = JavaCL.createBestContext();
		CLQueue queue = context.createDefaultQueue();

		String source = " void plusplus(int *i){i[0]= i[0]+1;}  " +
				" void add(__global float *a,__global float *b,__global float *c,__global int *i){int j = (int)i;c[j] = a[j] + b[j]; } \n" +
				"__kernel void kernel1 (__global  float* a, __global  float* b, __global float* output)     "
				+ "{                                                                                                     "
				+ "   int i = get_global_id(0);  " +
				   "  "+
				"    add(a,b,output,i); " +
				
				"     " +
				"                                                                 "
				+ "   " +
				"                                                                           "
				+ "}                                                                                                     "
				+" ";

		//CLKernel kernel = context.createProgram(kernel_1354633072).createKernel(		"kernel_1354633072");
		
		CLKernel kernel1 = context.createProgram(source).createKernel("kernel1");
		CLBuffer<Float> aBuf = context.createBuffer(CLMem.Usage.Input, a, true);
		CLBuffer<Float> bBuf = context.createBuffer(CLMem.Usage.Input, b, true);
		
		CLBuffer<Float> outBuf = context.createBuffer(CLMem.Usage.InputOutput, a, true);
//		CLBuffer<Float> outBuf = context.createBuffer(CLMem.Usage.InputOutput,
//				Float.class, n);
		kernel1.setArgs(aBuf, bBuf, outBuf);

		kernel1.enqueueNDRange(queue, new int[] { n });
		queue.finish();

		return outBuf.read(queue);
	}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
/**
 * Construct with the given OpenCL program
 * @param program the OpenCL program
 */
public CLImageProcessor(CLProgram program) {
	try {
		this.context = JavaCL.createBestContext(DeviceFeature.GPU);
		this.kernel = program.createKernels()[0];
	} catch (CLBuildException e) {
		//fallback to OpenCL on the CPU
		this.context = JavaCL.createBestContext(DeviceFeature.CPU);
		this.kernel = program.createKernels()[0];			
	}
}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
/**
 * Construct with the given OpenCL program
 * @param program the OpenCL program
 */
public CLImageAnalyser(CLProgram program) {
	try {
		this.context = JavaCL.createBestContext(DeviceFeature.GPU);
		this.kernel = program.createKernels()[0];
	} catch (CLBuildException e) {
		//fallback to OpenCL on the CPU
		this.context = JavaCL.createBestContext(DeviceFeature.CPU);
		this.kernel = program.createKernels()[0];			
	}
}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
public static Pointer<Integer> add(Pointer<Integer> a)
		throws CLBuildException {
	int n = (int) a.getValidElements();

	CLContext context = JavaCL.createBestContext();
	CLQueue queue = context.createDefaultQueue();


	CLKernel kernel1 = context.createProgram(kernel_1725551088).createKernel("kernel_1725551088");
	

	
	CLBuffer<Integer> outBuf = context.createBuffer(CLMem.Usage.InputOutput, a, true);
	CLBuffer<Integer> aa = context.createBuffer(CLMem.Usage.InputOutput, pointerToInt(0), true);

	
	kernel1.setArgs(aa,aa,outBuf);

	kernel1.enqueueNDRange(queue, new int[] { n });
	queue.finish();

	return outBuf.read(queue);
}
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {

        CLContext context = JavaCL.createBestContext();
        CLQueue clQueue = context.createDefaultQueue();
        ByteOrder byteOrder = context.getByteOrder();

        int n = 1024;
        Pointer<Float> aPtr = allocateFloats(n).order(byteOrder);

        for (int i = 0; i < n; i++) {
            aPtr.set(i, (float)cos(i));
        }

        // Create OpenCL input/output buffers (using the native memory pointers aPtr and bPtr) :
        CLBuffer<Float> a = context.createBuffer(Usage.InputOutput, aPtr);

        // Read the program sources and compile them :
        String src = 
                    "__kernel void add_floats(global float* a, int n) {\n" +
                    "      int i = get_global_id(0);\n" +
                    "      if(i < n){\n" +
                    "      	a[i] = 2.f*a[i];\n" +
                    "       }\n" +
                    "}";

    //IOUtils.readText(new File("TutorialKernels.cl"));
        CLProgram program = context.createProgram(src).build();
        
        // Get and call the kernel :
        CLKernel addFloatsKernel = program.createKernel("add_floats");

        addFloatsKernel.setArgs(a, n);
        CLEvent evt = addFloatsKernel.enqueueNDRange(clQueue, new int[] { n });

        aPtr =  a.read(clQueue, evt); // blocks until add_floats finished
      
        // Print the first 10 output values :
        for (int i = 0; i < 10 && i < n; i++) {
            System.out.println("out[" + i + "] = " + aPtr.get(i));
        }

    }
 

import com.nativelibs4java.opencl.JavaCL; //导入方法依赖的package包/类
@Before
public void setup() throws IOException {
    context = JavaCL.createBestContext();
    queue = context.createDefaultQueue();
    structs = new Structs(context);
}