摘要：介紹實際上就是對用語言進行了封裝，許多代碼都和一樣，這一點使得用過的可以非常快的上手，可以到查看源碼由于沒有指針，所以不得不用來獲取地址，這樣就感覺其實看起來比還要復雜開發環境搭建參考別人的文章完成開發環境搭建更新顯卡驅動安裝驅動，應該最新

jocl實際上就是對opencl用java語言進行了封裝，許多代碼都和opencl一樣，這一點使得用過opencl的可以非常快的上手，可以到github查看源碼

由于java沒有指針，所以jocl不得不用Pointer來獲取地址，這樣就感覺jocl其實看起來比opencl還要復雜

參考別人的文章https://my.oschina.net/qutter... 完成jocl開發環境搭建

更新顯卡驅動

安裝opencl驅動，應該最新版本的顯卡驅動都是支持opencl的，可以用 GPU Caps Viewer 來測試，如果沒有，AMD的話可以到https://support.amd.com/en-us... 下載驅動

下載opencl sdk

Inter https://software.intel.com/en...

AMD https://developer.amd.com/too...

Nvidia https://developer.nvidia.com/...

下載安裝jdk http://www.oracle.com/technet...，不要忘了設置環境變量

下載安裝eclipse http://www.eclipse.org/downlo...

下載jar包 http://www.jocl.org/downloads...，需要提取里面的相應jar文件放到項目Referenced Libraries里面，把dll文件放到jdk安裝路徑/bin下

現在可以直接到官網 http://www.jocl.org/samples/s... 找sample來運行了

原始的jocl就是對opencl的C語言的重寫，是比較麻煩的，下面給出封裝代碼

PackJocl.java

package jocl;

import static org.jocl.CL.CL_CONTEXT_PLATFORM;
import static org.jocl.CL.CL_DEVICE_TYPE_GPU;
import static org.jocl.CL.CL_MEM_COPY_HOST_PTR;
import static org.jocl.CL.CL_MEM_READ_ONLY;
import static org.jocl.CL.CL_TRUE;
import static org.jocl.CL.clBuildProgram;
import static org.jocl.CL.clCreateBuffer;
import static org.jocl.CL.clCreateCommandQueue;
import static org.jocl.CL.clCreateContext;
import static org.jocl.CL.clCreateKernel;
import static org.jocl.CL.clCreateProgramWithSource;
import static org.jocl.CL.clEnqueueNDRangeKernel;
import static org.jocl.CL.clEnqueueReadBuffer;
import static org.jocl.CL.clGetDeviceIDs;
import static org.jocl.CL.clGetPlatformIDs;
import static org.jocl.CL.clReleaseCommandQueue;
import static org.jocl.CL.clReleaseContext;
import static org.jocl.CL.clReleaseKernel;
import static org.jocl.CL.clReleaseMemObject;
import static org.jocl.CL.clReleaseProgram;
import static org.jocl.CL.clSetKernelArg;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

import org.jocl.CL;
import org.jocl.Pointer;
import org.jocl.Sizeof;
import org.jocl.cl_command_queue;
import org.jocl.cl_context;
import org.jocl.cl_context_properties;
import org.jocl.cl_device_id;
import org.jocl.cl_kernel;
import org.jocl.cl_mem;
import org.jocl.cl_platform_id;
import org.jocl.cl_program;

/**
 * A small JOCL sample.
 */
public class PackJocl
{
    cl_context context;                // 上下文
    cl_command_queue commandQueue;    // 命令隊列
    cl_program program;                // 程序對象
    cl_kernel kernel;                // Kernel對象
    cl_mem memObjects[];            // 內存對象數組
    
    /**
     * 讀取文件的內容
     * @param file 想要讀取的文件對象
     * @return 返回文件內容
     */
    public static String readCl(File file){
        StringBuilder result = new StringBuilder();
        try{
            BufferedReader br = new BufferedReader(new FileReader(file));//構造一個BufferedReader類來讀取文件
            String s = null;
            while((s = br.readLine())!=null){//使用readLine方法，一次讀一行
                result.append(System.lineSeparator()+s);
            }
            br.close();    
        }catch(Exception e){
            e.printStackTrace();
        }
        return result.toString();
    }
    
    PackJocl(){
        
    }
    
    /**
     * 加載平臺和驅動
     * @param platformIdx 平臺index
     * @param deviceIdx 驅動index
     */
    @SuppressWarnings("deprecation")
    public void init(int platformIdx, int deviceIdx){
        final int platformIndex = platformIdx; // 選擇哪個平臺
        final long deviceType = CL_DEVICE_TYPE_GPU;
        final int deviceIndex = deviceIdx;

        // 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);
        cl_device_id device = devices[deviceIndex];
        context = clCreateContext(
        contextProperties, 1, new cl_device_id[]{device}, 
        null, null, null);
    
        // Create a command-queue for the selected device
        commandQueue = clCreateCommandQueue(context, device, 0, null);
    }
    
    /**
     * 創建Kernel
     * @param clName Kernel文件名
     * @param funcName Kernel函數名
     */
    public void createKernel(String clName, String funcName){
        program = clCreateProgramWithSource(context, 1, new String[]{  readCl(new File(clName)) }, null, null);
        
        // Build the program
        clBuildProgram(program, 0, null, null, null, null);
            
        // Create the kernel
        kernel = clCreateKernel(program, funcName, null);
    }
    
    /**
     * 創建Kernel
     * @param p 包含所有參數的指針數組
     * @param n 分配內存空間大小 
     */
    public void setParameters(Pointer[] p, int n){
        memObjects = new cl_mem[p.length];
        for(int i = 0; i < p.length; i++){
            memObjects[i] = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, Sizeof.cl_float * n, p[i], null);
        }
        
        for(int i = 0; i < p.length; i++){
            clSetKernelArg(kernel, i, Sizeof.cl_mem, Pointer.to(memObjects[i]));
        }
        
    }
    
    /**
     * 執行Kernel
     * @param dim 維數
     * @param global_work_size[] global_work_size
     * @param local_work_size[] local_work_size
     */
    public void execute(int dim, long global_work_size[], long local_work_size[]){
         // Execute the kernel
         clEnqueueNDRangeKernel(commandQueue, kernel, dim, null,global_work_size, local_work_size, 0, null, null);
    }

    /**
     * 把顯存里的計算結果取回內存
     * @param index 參數位置
     * @param dstPointer 結果指針
     * @param size 分配內存空間大小 
     */
    public void getData(int index, Pointer dstPointer, int size){
         clEnqueueReadBuffer(commandQueue, memObjects[index], CL_TRUE, 0, size * Sizeof.cl_float, dstPointer, 0, null, null);
    }
    
    public void clear(){
         clReleaseMemObject(memObjects[0]);
         clReleaseMemObject(memObjects[1]);
         clReleaseMemObject(memObjects[2]);
         clReleaseKernel(kernel);
         clReleaseProgram(program);
         clReleaseCommandQueue(commandQueue);
         clReleaseContext(context);
    }
  
}

PackageTest.java

package jocl;

import org.jocl.Pointer;

public class PackageTest {
    public static void main(String args[]){
        PackJocl  jocl= new PackJocl();
        
        // 初始化，第一個參數是平臺index，第二個參數是驅動index
        jocl.init(1,0);
        
        // 創建內核， 第一個是內核文件名，第二個是內核函數名
        jocl.createKernel("E://kernel.cl", "add");
        
        // 獲取測試數據并復制到顯存
        int n = 10;
        float srcArrayA[] = new float[n];
        float srcArrayB[] = new float[n];
        float dstArray[] = new float[n];
        for (int i=0; i
kernel.cl 我是放在E盤根目錄下，所以PackageTest.java中寫的jocl.createKernel("E://kernel.cl", "add"); 你可以改成其他的
__kernel void add(__global const float *a, __global const float *b, __global float *c)
{
    int gid = get_global_id(0);
    printf("%d	",gid);
    c[gid] = a[gid] + b[gid];
}
運行結果

第一次寫文章，希望可以幫助到你
本文同步更新我的個人博客https://blog.yjqing.xin/jocl