import org.jocl.Sizeof; //导入依赖的package包/类
void loadFragments() {
	for (String k : Data.fragments.keySet()) {
		Frag smallFrag = Data.fragments.get(k);// get fragment
		int[] smallMatrix = flat(smallFrag.getRgbData());// copy rgbData to
															// 1d
		// buffer
		Pointer smallPointer = Pointer.to(smallMatrix); // create a pointer
														// to that 1d buffer
		// load data to GPU
		cl_mem memObj = clCreateBuffer(context, CL_MEM_READ_ONLY
				| CL_MEM_COPY_HOST_PTR, Sizeof.cl_int * smallMatrix.length,
				smallPointer, null);
		// get pointer to data on GPU
		fragMemObjects.put(k, memObj);
	}
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void createBuffers() {
	bigMatrixArray = new int[screenRect.width * screenRect.height];
	// load data
	bigMatrixPointer = Pointer.to(bigMatrixArray); // create a pointer to
													// that 1d buffer
	memObjects[0] = clCreateBuffer(context, CL_MEM_READ_ONLY
			| CL_MEM_COPY_HOST_PTR, Sizeof.cl_int * bigMatrixArray.length,
			bigMatrixPointer, null);
	resultFromGPUArrayPointer = Pointer.to(resultFromGPUArray);
	kernelInstrArrayPointer = Pointer.to(kernel_instruction_buffers);

	memObjects[2] = clCreateBuffer(context, CL_MEM_READ_WRITE
			| CL_MEM_COPY_HOST_PTR, Sizeof.cl_int * resultArraySize,
			resultFromGPUArrayPointer, null);
	memObjects[3] = clCreateBuffer(context, CL_MEM_READ_WRITE
			| CL_MEM_COPY_HOST_PTR, Sizeof.cl_int
			* kernel_instruction_buffers.length, kernelInstrArrayPointer,
			null);

}
 

import org.jocl.Sizeof; //导入依赖的package包/类
/**
 * Returns the values of the info parameter with the given name
 *
 * @param infoGetter The info getter
 * @param object     The object
 * @param paramName  The parameter name
 * @param <T>        The object type
 * @param numValues  The number of values
 *
 * @return The values
 */
static <T> long[] getSizes(
  InfoGetter<T> infoGetter, T object, int paramName, int numValues)
{
  ByteBuffer buffer = ByteBuffer.allocate(
    numValues * Sizeof.size_t).order(ByteOrder.nativeOrder());
  infoGetter.get(object, paramName, Pointer.to(buffer));
  long values[] = new long[numValues];
  if(Sizeof.size_t == 4)
  {
    for(int i = 0; i < numValues; i++)
    {
      values[i] = buffer.getInt(i * Sizeof.size_t);
    }
  }
  else
  {
    for(int i = 0; i < numValues; i++)
    {
      values[i] = buffer.getLong(i * Sizeof.size_t);
    }
  }
  return values;
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
/**
 * Creates a new Pointer to the given buffer, taking into account the position and array offset of the given buffer.
 *
 * @param buffer The buffer
 *
 * @return The pointer
 *
 * @throws IllegalArgumentException If the given buffer is null or is neither direct nor has a backing array
 */
private static Pointer computePointer(ByteBuffer buffer)
{
  Pointer result = null;
  if(buffer.isDirect())
  {
    int oldPosition = buffer.position();
    buffer.position(0);
    result = Pointer.to(buffer.slice()).withByteOffset(
      oldPosition * Sizeof.cl_char);
    buffer.position(oldPosition);
  }
  else if(buffer.hasArray())
  {
    ByteBuffer t = ByteBuffer.wrap(buffer.array());
    int elementOffset = buffer.position() + buffer.arrayOffset();
    result = Pointer.to(t).withByteOffset(
      elementOffset * Sizeof.cl_char);
  }
  else
  {
    throw new IllegalArgumentException(
      "Buffer may not be null and must have an array or be direct");
  }
  return result;
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
private void writeBinary(cl_program program, String nameKernel,
    String nameDevice) {
int nrDevices = 1;
long[] sizes = new long[nrDevices];
clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, nrDevices
	* Sizeof.size_t, Pointer.to(sizes), null);
byte[][] buffers = new byte[nrDevices][(int) sizes[0] + 1];
Pointer[] pointers = new Pointer[nrDevices];
pointers[0] = Pointer.to(buffers[0]);
Pointer p = Pointer.to(pointers);
clGetProgramInfo(program, CL_PROGRAM_BINARIES, nrDevices
	* Sizeof.POINTER, p, null);
String binary = new String(buffers[0], 0, buffers[0].length - 1).trim();
try {
    PrintStream out = new PrintStream(new File(nameDevice + "_"
	    + nameKernel + ".ptx"));
    out.println(binary);
    out.close();
} catch (IOException e) {
    System.err.println(e.getMessage());
}
   }
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void scheduleReads(ArrayList<cl_event> waitListEvents, ArrayList<cl_event>
    readBufferEvents) {
if (direction == Direction.OUT || direction == Direction.INOUT) {
    cl_event event = readBuffer(readQueue, waitListEvents, bs.length *
	    Sizeof.cl_char, Pointer.to(bs));
    //MCCashmere.stats.kernelTimer.stop();
    //MCCashmere.stats.dToHTimer.start();
    /*
    clSetEventCallback(event, CL_COMPLETE, new EventCallbackFunction() {
	public void function(cl_event event, int commandCallbackType, 
	    Object userdata) {
	    cleanCallback();
	}
    }, null);
    */
    if (event != null) {
	readBufferEvents.add(event);
    }
}
cleanCallback();
   }
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void scheduleReads(ArrayList<cl_event> waitListEvents, ArrayList<cl_event>
    readBufferEvents) {
if (direction == Direction.OUT || direction == Direction.INOUT) {
    cl_event event = readBuffer(readQueue, waitListEvents, fs.length *
	    Sizeof.cl_float, Pointer.to(fs));
    //MCCashmere.stats.kernelTimer.stop();
    //MCCashmere.stats.dToHTimer.start();
    /*
    clSetEventCallback(event, CL_COMPLETE, new EventCallbackFunction() {
	public void function(cl_event event, int commandCallbackType, 
	    Object userdata) {
	    cleanCallback();
	}
    }, null);
    */
    if (event != null) {
	readBufferEvents.add(event);
    }
}
cleanCallback();
   }
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void scheduleReads(ArrayList<cl_event> waitListEvents, ArrayList<cl_event>
    readBufferEvents) {
if (direction == Direction.OUT || direction == Direction.INOUT) {
    cl_event event = readBuffer(readQueue, waitListEvents, is.length *
	    Sizeof.cl_int, Pointer.to(is));
    //MCCashmere.stats.kernelTimer.stop();
    //MCCashmere.stats.dToHTimer.start();
    /*
    clSetEventCallback(event, CL_COMPLETE, new EventCallbackFunction() {
	public void function(cl_event event, int commandCallbackType, 
	    Object userdata) {
	    cleanCallback();
	}
    }, null);
    */
    if (event != null) {
	readBufferEvents.add(event);
    }
}
cleanCallback();
   }
 

import org.jocl.Sizeof; //导入依赖的package包/类
private void prepareCLMem() {
	weightsCL=new cl_mem[weights.length];
	deltaWeightsCL=new cl_mem[weights.length];
	outputsCL=new cl_mem[weights.length];
	errorCL=new cl_mem[weights.length];
	
	float[] wagiCLSrc;
	
	int index;
	for(int i=0;i<weights.length;i++) {
		//int connectionsNumber=;
		wagiCLSrc=new float[weights[i].length*(i==0?inputsNumber+1:weights[i-1].length+1)];
		
		index=0;
		for(int j=0;j<weights[i].length;j++) {
			for(int k=0;k<weights[i][j].length;k++) {
				wagiCLSrc[index]=weights[i][j][k];
				index++;
			}
		}
		weightsCL[i]=CL.clCreateBuffer(context, CL.CL_MEM_READ_WRITE|CL.CL_MEM_COPY_HOST_PTR, Sizeof.cl_float*(index+1), Pointer.to(wagiCLSrc), null);
		deltaWeightsCL[i]=CL.clCreateBuffer(context, CL.CL_MEM_READ_WRITE|CL.CL_MEM_HOST_NO_ACCESS, Sizeof.cl_float*(index+1), null, null);
		
		outputsCL[i]=CL.clCreateBuffer(context, CL.CL_MEM_READ_WRITE|CL.CL_MEM_COPY_HOST_PTR, Sizeof.cl_float*(layersSize[i+1]+1), Pointer.to(new float[] {1}), null);
		errorCL[i]=CL.clCreateBuffer(context, CL.CL_MEM_READ_WRITE, Sizeof.cl_float*(layersSize[i+1]), null, null);								//TODO NN add host_no_acess flag
		//System.out.println("layersSize["+(i+1)+"]="+layersSize[i+1]);
		//System.out.println("error["+i+"].length="+error[i].length);
	}
	if(learningSeqence!=null)
		for(LearningSeqence ls:learningSeqence)
			ls.initializeCL(context,commandQueue);
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public final float[] getOutput() {
	if(openCLLoaded) {
		if(output==null) {
			float[] outputs=new float[layersSize[layersNumber]];
			CL.clEnqueueReadBuffer(commandQueue, outputsCL[layersNumber-1], CL.CL_TRUE, 0, Sizeof.cl_float*layersSize[layersNumber], Pointer.to(outputs), 0, null, null);
			return outputs;
		}
		CL.clEnqueueReadBuffer(commandQueue, outputsCL[layersNumber-1], CL.CL_TRUE, 0, Sizeof.cl_float*layersSize[layersNumber], Pointer.to(output[layersNumber-1]), 0, null, null);
	}
	return output[layersNumber-1];
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void lSimulate(int nrElement){
	if(openCLLoaded) {
		for(int nrLayer=0;nrLayer<layersNumber;nrLayer++){
			cl_mem inputDataCL;
			if(nrLayer==0){															//Input layer
				inputDataCL=learningSeqence[nrElement].inputsCL;
			}else{																	//Input layer
				inputDataCL=outputsCL[nrLayer-1];
			}
			
			int neurons=layersSize[nrLayer+1];
			int connections=layersSize[nrLayer]+1;
			
			CL.clSetKernelArg(simulateKernel, 0, Sizeof.cl_mem, Pointer.to(weightsCL[nrLayer]));
			CL.clSetKernelArg(simulateKernel, 1, Sizeof.cl_mem, Pointer.to(inputDataCL));
			CL.clSetKernelArg(simulateKernel, 2, Sizeof.cl_mem, Pointer.to(outputsCL[nrLayer]));
			CL.clSetKernelArg(simulateKernel, 3, Sizeof.cl_int, Pointer.to(new int[] {connections}));
			CL.clEnqueueNDRangeKernel(commandQueue, simulateKernel, 1, null ,new long[] {neurons}, new long[]{1}, 0, null, null);
			}
	}else {
		for(int nrLayer=0;nrLayer<layersNumber;nrLayer++){
			float[] inputData;
			if(nrLayer==0){															//Input layer
				inputData=learningSeqence[nrElement].inputs;
			}
			else{																	//Output layer
				inputData=output[nrLayer-1];
			}
			
			for(int i=0;i<weights[nrLayer].length;i++) {
				output[nrLayer][i]=weights[nrLayer][i][0];
				for(int j=1;j<weights[nrLayer][i].length;j++){
					output[nrLayer][i]+=weights[nrLayer][i][j]*inputData[j-1];
				}
				
				output[nrLayer][i]=function.function(output[nrLayer][i]);
			}
		}
	}
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void coutError(int nrElementu){
	boolean pom=true;
	
	if(openCLLoaded) {
		CL.clSetKernelArg(outputLayerErrorKernel, 0, Sizeof.cl_mem, Pointer.to(errorCL[layersNumber-1]));			//Input layer
		CL.clSetKernelArg(outputLayerErrorKernel, 1, Sizeof.cl_mem, Pointer.to(outputsCL[layersNumber-1]));
		CL.clSetKernelArg(outputLayerErrorKernel, 2, Sizeof.cl_mem, Pointer.to(learningSeqence[nrElementu].outputsCL));
		CL.clEnqueueNDRangeKernel(commandQueue, outputLayerErrorKernel, 1, null, new long[] {layersSize[layersNumber-1]}, new long[] {1}, 0, null, null);
		
		for(int nrLayer=layersNumber-2;nrLayer>-1;nrLayer--){													//Hidden layer
			int neurons=layersSize[nrLayer+1];			//WTF? this work
			int connections=layersSize[nrLayer+1];
			
			CL.clSetKernelArg(calculateErrorKernel, 0, Sizeof.cl_mem, Pointer.to(weightsCL[nrLayer+1]));
			CL.clSetKernelArg(calculateErrorKernel, 1, Sizeof.cl_mem, Pointer.to(errorCL[nrLayer+1]));
			CL.clSetKernelArg(calculateErrorKernel, 2, Sizeof.cl_mem, Pointer.to(errorCL[nrLayer]));
			CL.clSetKernelArg(calculateErrorKernel, 3, Sizeof.cl_int, Pointer.to(new int[] {connections+1}));
			CL.clEnqueueNDRangeKernel(commandQueue, calculateErrorKernel, 1, null, new long[] {neurons}, new long[] {1}, 0, null, null);
		}
	}else {
		for(int nrLayer=weights.length-1;nrLayer>-1;nrLayer--){
			if(pom){																							//Input layer
				for(int i=0;i<weights[nrLayer].length;i++){
					error[nrLayer][i]=learningSeqence[nrElementu].outputs[i]-output[nrLayer][i];				//Dont't have to reset error
				}
				pom=false;
			}else{																								//Hidden layer
				for(int i=0;i<weights[nrLayer].length;i++)														//Reset error
					error[nrLayer][i]=0;
				
				for(int i=0;i<weights[nrLayer+1].length;i++){
					for(int j=0;j<weights[nrLayer+1][i].length-1;j++){
						error[nrLayer][j]+=error[nrLayer+1][i]*weights[nrLayer+1][i][j+1];
					}
				}
			}
		}
	}
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void endLearning() {
	if(openCLLoaded) {
		float[] weightsBuffer;
		int neurons;
		int connections;
		int index;
		
		if(weights==null) {
			weights=new float[layersNumber][][];
			
			for(int i=0;i<layersNumber;i++) {
				weights[i]=new float[layersSize[i+1]][layersSize[i]];
			}
		}
		
		for(int i=0;i<layersNumber;i++) {
			neurons=layersSize[i+1];
			connections=layersSize[i]+1;
			index=0;
			
			weightsBuffer=new float[neurons*connections];
			CL.clEnqueueReadBuffer(commandQueue, weightsCL[i], CL.CL_TRUE, 0, Sizeof.cl_float*weightsBuffer.length, Pointer.to(weightsBuffer), 0, null, null);
			
			for(int j=0;j<neurons;j++) {
				for(int k=0;k<connections;k++) {
					weights[i][j][k]=weightsBuffer[index++];
				}
			}
		}
	}
	learning=false;
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void grab() throws Exception {
	super.grab();
	// create buffers
	// bigMatrixArray = new int[screenRect.width * screenRect.height];
	// load data
	// bigMatrixArray = flat(screenFrag.rgbData);
	int[][] matrix = screenFrag.getRgbData();
	int width = matrix[0].length;
	for (int i = 0; i < matrix.length; i++)
		System.arraycopy(matrix[i], 0, bigMatrixArray, width * i, width);

	clEnqueueWriteBuffer(commandQueue, memObjects[0], CL_TRUE, 0,
			bigMatrixArray.length * Sizeof.cl_int, bigMatrixPointer, 0,
			null, null);
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public int findLowest(byte[] gensig, byte[] data)
{
  cl_mem dataMem, deadlineMem;

  long numNonces = data.length / 64;
  long calcWorkgroups = numNonces / workgroupSize[0];
  // thx blago
  if(numNonces % workgroupSize[0] != 0) // if(numNonces % 64 != 0) // org.
  {
    calcWorkgroups++;
  }
  clEnqueueWriteBuffer(queue, gensigMem, false, 0, 32, Pointer.to(gensig), 0, null, null);
  dataMem = clCreateBuffer(context, CL_MEM_READ_ONLY, calcWorkgroups * workgroupSize[0] * 64, null, null);
  clEnqueueWriteBuffer(queue, dataMem, false, 0, data.length, Pointer.to(data), 0, null, null);
  deadlineMem = clCreateBuffer(context, CL_MEM_READ_WRITE, calcWorkgroups * workgroupSize[0] * 8, null, null);
  clSetKernelArg(kernel[0], 0, Sizeof.cl_mem, Pointer.to(gensigMem));
  clSetKernelArg(kernel[0], 1, Sizeof.cl_mem, Pointer.to(dataMem));
  clSetKernelArg(kernel[0], 2, Sizeof.cl_mem, Pointer.to(deadlineMem));
  clEnqueueNDRangeKernel(queue, kernel[0], 1, null, new long[]{calcWorkgroups * workgroupSize[0]}, new long[]{workgroupSize[0]}, 0, null, null);
  clSetKernelArg(kernel[1], 0, Sizeof.cl_mem, Pointer.to(deadlineMem));
  long len[] = {data.length / 64};
  clSetKernelArg(kernel[1], 1, Sizeof.cl_uint, Pointer.to(len));
  clSetKernelArg(kernel[1], 2, Sizeof.cl_uint * workgroupSize[1], null);
  clSetKernelArg(kernel[1], 3, Sizeof.cl_ulong * workgroupSize[1], null);
  clSetKernelArg(kernel[1], 4, Sizeof.cl_mem, Pointer.to(bestMem));
  clEnqueueNDRangeKernel(queue, kernel[1], 1, null, new long[]{workgroupSize[1]}, new long[]{workgroupSize[1]}, 0, null, null);
  int best[] = new int[1];
  clEnqueueReadBuffer(queue, bestMem, true, 0, 4, Pointer.to(best), 0, null, null);
  clReleaseMemObject(dataMem);
  clReleaseMemObject(deadlineMem);
  return best[0];
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
/**
 * Enqueue a command to read the given buffer into the given target Buffer. The size of the data transfer will be computed from the position and limit of the
 * given Buffer.
 *
 * @param commandQueue The command queue
 * @param buffer       The source buffer
 * @param sourceOffset The offset (in number of elements) in the source buffer
 * @param target       The target Buffer
 * @param blocking     Whether the transfer should be blocking
 * @param waitList     The event wait list. May be <code>null</code>.
 * @param event        The event for this command. May be <code>null</code>.
 */
public static void enqueueReadBuffer(
  cl_command_queue commandQueue,
  cl_mem buffer,
  long sourceOffset,
  ByteBuffer target,
  boolean blocking,
  List<cl_event> waitList, cl_event event)
{
  Pointer targetPointer = PointerUtils.toBuffer(target);
  clEnqueueReadBuffer(commandQueue, buffer, blocking,
                      sourceOffset * Sizeof.cl_char,
                      target.remaining() * Sizeof.cl_char, targetPointer,
                      sizeOf(waitList), asArray(waitList), event);
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
/**
 * Enqueue a command to write the given buffer from the given source Buffer. The size of the data transfer will be computed from the position and limit of the
 * given Buffer.
 *
 * @param commandQueue The command queue
 * @param buffer       The target buffer
 * @param targetOffset The offset (in number of elements) in the target buffer
 * @param source       The source Buffer
 * @param blocking     Whether the transfer should be blocking
 * @param waitList     The event wait list. May be <code>null</code>.
 * @param event        The event for this command. May be <code>null</code>.
 */
public static void enqueueWriteBuffer(
  cl_command_queue commandQueue,
  cl_mem buffer,
  long targetOffset,
  ByteBuffer source,
  boolean blocking,
  List<cl_event> waitList, cl_event event)
{
  Pointer sourcePointer = PointerUtils.toBuffer(source);
  clEnqueueWriteBuffer(commandQueue, buffer, blocking,
                       targetOffset * Sizeof.cl_char,
                       source.remaining() * Sizeof.cl_char, sourcePointer,
                       sizeOf(waitList), asArray(waitList), event);
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
/**
 * The properties of the context.
 *
 * @param context The context
 *
 * @return The value
 */
public static long[] getProperties(cl_context context)
{
  long valueSize = Infos.FOR_CONTEXT.getSize(context,
                                             CL_CONTEXT_PROPERTIES);
  int numValues = (int) (valueSize / Sizeof.POINTER);
  return Infos.getSizes(Infos.FOR_CONTEXT, context,
                        CL_CONTEXT_PROPERTIES, numValues);
}
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void setArgument(float[][] a, Argument.Direction d) { 
//MCCashmere.stats.hToDTimer.start();
FloatArray2DArgument arg = new FloatArray2DArgument(context,
	writeQueue, readQueue, writeBufferEvents, a, d, prevWrites);
setArgument(Sizeof.cl_mem, arg);
argsToClean.add(arg);
   }
 

import org.jocl.Sizeof; //导入依赖的package包/类
public void setArgumentNoCopy(float[] a) {
FloatArrayArgument arg = device.getArgument(a);
setArgument(Sizeof.cl_mem, arg);

// make the execute dependent on this copy.
addWriteEvent(device.getWriteEvent(a));
noCopyFloats.add(a);
   }