C++ clEnqueueUnmapMemObject函数代码示例

static void release_clobj(void) {
    cl_int ret_code;

    ret_code = clEnqueueUnmapMemObject(queue[ocl_gpu_id], pinned_partial_hashes,
            calculated_hash, 0, NULL, NULL);
    HANDLE_CLERROR(ret_code, "Error Ummapping out_hashes");

    ret_code = clEnqueueUnmapMemObject(queue[ocl_gpu_id], pinned_saved_keys,
            plaintext, 0, NULL, NULL);
    HANDLE_CLERROR(ret_code, "Error Ummapping saved_plain");

    ret_code = clReleaseMemObject(salt_buffer);
    HANDLE_CLERROR(ret_code, "Error Releasing data_info");
    ret_code = clReleaseMemObject(pass_buffer);
    HANDLE_CLERROR(ret_code, "Error Releasing buffer_keys");
    ret_code = clReleaseMemObject(hash_buffer);
    HANDLE_CLERROR(ret_code, "Error Releasing buffer_out");
    ret_code = clReleaseMemObject(work_buffer);
    HANDLE_CLERROR(ret_code, "Error Releasing work_out");

    ret_code = clReleaseMemObject(pinned_saved_keys);
    HANDLE_CLERROR(ret_code, "Error Releasing pinned_saved_keys");

    ret_code = clReleaseMemObject(pinned_partial_hashes);
    HANDLE_CLERROR(ret_code, "Error Releasing pinned_partial_hashes");
}

static void release_clobj(void)
{
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], cl_aes_key, aes_key, 0, NULL, NULL), "Error Unmapping aes_key");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], cl_aes_iv, aes_iv, 0, NULL, NULL), "Error Unmapping aes_iv");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], cl_saved_key, saved_key, 0, NULL, NULL), "Error Unmapping saved_key");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], cl_saved_len, saved_len, 0, NULL, NULL), "Error Unmapping saved_len");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], cl_salt, saved_salt, 0, NULL, NULL), "Error Unmapping saved_salt");
	aes_key = NULL; aes_iv = NULL; saved_key = NULL; saved_len = NULL; saved_salt = NULL;
}

	void allochostptr_roundtrip_func()
	{
	timer.Start(timer_id);

		cl_int err;
		// Create buffers with CL_MEM_ALLOC_HOST_PTR for zero copy
        buffer_.buf_a_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY | CL_MEM_ALLOC_HOST_PTR,
                                       (buffer_.lda_*buffer_.a_num_vectors_ +
                                           buffer_.offA_) * sizeof(T),
                                       NULL, &err);

        buffer_.buf_b_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY | CL_MEM_ALLOC_HOST_PTR,
                                        (buffer_.ldb_ * buffer_.b_num_vectors_ +
                                            buffer_.offB_) * sizeof(T),
                                        NULL, &err);

        buffer_.buf_c_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
                                        (buffer_.ldc_ * buffer_.c_num_vectors_ +
                                            buffer_.offC_) * sizeof(T),
                                        NULL, &err);

		// map the buffers to pointers at host device
		T *map_a,*map_b,*map_c;
		map_a = (T*)clEnqueueMapBuffer(queues_[0], buffer_.buf_a_, CL_TRUE, CL_MAP_WRITE, 0, 
										  (buffer_.lda_*buffer_.a_num_vectors_ +
                                           buffer_.offA_) * sizeof(T),
										   0, NULL, NULL, &err);
		map_b = (T*)clEnqueueMapBuffer(queues_[0], buffer_.buf_b_, CL_TRUE, CL_MAP_WRITE, 0, 
										  (buffer_.ldb_*buffer_.b_num_vectors_ +
                                           buffer_.offB_) * sizeof(T),
										   0, NULL, NULL, &err);
	    map_c = (T*)clEnqueueMapBuffer(queues_[0], buffer_.buf_c_, CL_TRUE, CL_MAP_WRITE, 0, 
										  (buffer_.lda_*buffer_.c_num_vectors_ +
                                           buffer_.offC_) * sizeof(T),
										   0, NULL, NULL, &err);
		// memcpy the input A, B, C to the host pointers
		memcpy( map_a, buffer_.a_, ( buffer_.lda_*buffer_.a_num_vectors_ + buffer_.offA_) * sizeof( T ) );
		memcpy( map_b, buffer_.b_, ( buffer_.ldb_*buffer_.b_num_vectors_ + buffer_.offB_) * sizeof( T ) );
		memcpy( map_c, buffer_.c_, ( buffer_.ldc_*buffer_.c_num_vectors_ + buffer_.offC_) * sizeof( T ) );
		// unmap the buffers
		clEnqueueUnmapMemObject(queues_[0], buffer_.buf_a_, map_a, 0, NULL, NULL);
		clEnqueueUnmapMemObject(queues_[0], buffer_.buf_b_, map_b, 0, NULL, NULL);
		clEnqueueUnmapMemObject(queues_[0], buffer_.buf_c_, map_c, 0, NULL, NULL);
		// calling clBLAS
		xGemm_Function(false);
		// map the C buffer again to read output
	    map_c = (T*)clEnqueueMapBuffer(queues_[0], buffer_.buf_c_, CL_TRUE, CL_MAP_READ, 0, 
										  (buffer_.lda_*buffer_.c_num_vectors_ +
                                           buffer_.offC_) * sizeof(T),
										   0, NULL, NULL, &err);
		memcpy( map_c, buffer_.c_, ( buffer_.ldc_*buffer_.c_num_vectors_ + buffer_.offC_) * sizeof( T ) );
		clEnqueueUnmapMemObject(queues_[0], buffer_.buf_c_, map_c, 0, NULL, &event_);
		clWaitForEvents(1, &event_);

	timer.Stop(timer_id);
	}

static void release_clobj(void){
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], pinned_partial_hashes, partial_hashes, 0,NULL,NULL), "Error Unmapping partial_hashes");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[ocl_gpu_id], pinned_saved_keys, saved_plain, 0, NULL, NULL), "Error Unmapping saved_plain");

	HANDLE_CLERROR(clReleaseMemObject(buffer_keys), "Error Releasing buffer_keys");
	HANDLE_CLERROR(clReleaseMemObject(buffer_out), "Error Releasing buffer_out");
	HANDLE_CLERROR(clReleaseMemObject(pinned_saved_keys), "Error Releasing pinned_saved_keys");
	HANDLE_CLERROR(clReleaseMemObject(pinned_partial_hashes), "Error Releasing pinned_partial_hashes");
	MEM_FREE(res_hashes);
}

vector<cpx> cl_fft<cpx>::run(const vector<cpx> &input)
{
	cl_event upload_unmap_evt, start_evt, download_map_evt, *kernel_evts = new cl_event[launches.size()];
	cl_int err;

	// Upload
	cl_float2 *input_buffer = (cl_float2*)clEnqueueMapBuffer(command_queue,
		v_samples,
		CL_TRUE,
		CL_MAP_WRITE,
		0,
		samplesMemSize,
		0,
		NULL,
		NULL,
		&err);
	CL_CHECK_ERR("clEnqueueMapBuffer", err);

	for (int i = 0; i < samplesPerRun; i++)
	{
		input_buffer[i].x = real(input[i]);
		input_buffer[i].y = imag(input[i]);
	}

	CL_CHECK_ERR("clEnqueueUnmapMemObject", clEnqueueUnmapMemObject(command_queue, v_samples, input_buffer, 0, NULL, &upload_unmap_evt));

	// Calcola la FFT
	cl_mem v_out = runInternal(v_samples, &start_evt, kernel_evts);

	// Download
	vector<cpx> result(samplesPerRun);
	cl_float2 *output_buffer = (cl_float2*)clEnqueueMapBuffer(command_queue,
		v_out,
		CL_TRUE,
		CL_MAP_READ,
		0,
		tmpMemSize,
		1,
		&kernel_evts[launches.size() - 1],
		&download_map_evt,
		&err);
	CL_CHECK_ERR("clEnqueueMapBuffer", err);

	for (int i = 0; i < samplesPerRun; i++)
		result[i] = cpx(output_buffer[i].x, output_buffer[i].y);

	CL_CHECK_ERR("clEnqueueUnmapMemObject", clEnqueueUnmapMemObject(command_queue, v_out, output_buffer, 0, NULL, NULL));

	printStatsAndReleaseEvents(upload_unmap_evt, start_evt, kernel_evts, download_map_evt);

	delete[] kernel_evts;

	return result;
}

void init()
{
    int i, j;
    double t_start_init, t_end_init;

#ifndef ALOCACAO_NORMAL
    t_start_init = rtclock();	
    cl_float* x1_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, x1_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * N, 0, NULL, NULL, &errcode);
    cl_float* x2_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, x2_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * N, 0, NULL, NULL, &errcode);
    cl_float* y_1_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, y1_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * N, 0, NULL, NULL, &errcode);
    cl_float* y_2_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, y2_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * N, 0, NULL, NULL, &errcode);
    cl_float* a_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, a_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * N * N, 0, NULL, NULL, &errcode);
    t_end_init = rtclock();
    tmp_clEnqueueMapBuffer += t_end_init - t_start_init;
#else
    DATA_TYPE *y_1_input = y_1;
    DATA_TYPE *y_2_input = y_2;
    DATA_TYPE *a_input = a;
#endif	

    t_start_init = rtclock();
    for (i=0; i<N; i++) 
    {
        x1[i] = 0.0;
        x2[i] = 0.0;
#ifndef ALOCACAO_NORMAL	
        x1_input[i] = 0.0;
        x2_input[i] = 0.0;
#endif
        y_1_input[i] = 0.0;
        y_2_input[i] = 0.0;

        for (j=0; j<N; j++)
        {
            a_input[i*N + j] = (DATA_TYPE)(i+j+1.0)/N;
        }
    }
    t_end_init = rtclock();
    tmp_init += t_end_init - t_start_init;
#ifndef ALOCACAO_NORMAL
    t_start_init = rtclock();
    clEnqueueUnmapMemObject(clCommandQue, x1_mem_obj, x1_input, 0, NULL, NULL);
    clEnqueueUnmapMemObject(clCommandQue, x2_mem_obj, x2_input, 0, NULL, NULL);
    clEnqueueUnmapMemObject(clCommandQue, y1_mem_obj, y_1_input, 0, NULL, NULL);
    clEnqueueUnmapMemObject(clCommandQue, y2_mem_obj, y_2_input, 0, NULL, NULL);
    clEnqueueUnmapMemObject(clCommandQue, a_mem_obj, a_input, 0, NULL, NULL);
    t_end_init = rtclock();
    tmp_clEnqueueUnmapMemObject += t_end_init - t_start_init; 
#endif
}

void QCLVectorBase::unmap() const
{
    if (m_mapped) {
#ifndef QT_CL_COPY_VECTOR
        cl_int error = clEnqueueUnmapMemObject
            (d_ptr->context->activeQueue(), d_ptr->id, m_mapped, 0, 0, 0);
        d_ptr->context->reportError("QCLVector<T>::unmap:", error);
#else
        // Write the local copy back to the OpenCL device.
        if (d_ptr->hostCopy && d_ptr->state == State_InHost) {
            cl_int error = clEnqueueWriteBuffer
                (d_ptr->context->activeQueue(), d_ptr->id, CL_FALSE,
                 0, m_size * m_elemSize, d_ptr->hostCopy, 0, 0, 0);
            d_ptr->context->reportError("QCLVector<T>::unmap(write):", error);
        }
        d_ptr->state = State_InKernel;
#endif
        m_mapped = 0;

        // Update all of the other owners with the unmap state.
        if (d_ptr->owners.size() > 1) {
            QList<QCLVectorBase *>::Iterator it;
            for (it = d_ptr->owners.begin(); it != d_ptr->owners.end(); ++it) {
                if (*it != this)
                    (*it)->m_mapped = 0;
            }
        }
    }
}

void timedBufUnmap( cl_command_queue queue,
                    cl_mem buf,
                    void **ptr,
                    bool quiet )
{
    CPerfCounter t1;
    cl_int ret;
    cl_event ev;

    t1.Reset();
    t1.Start();

    ret = clEnqueueUnmapMemObject( queue,
                                   buf,
                                   (void *) *ptr,
                                   0, NULL, &ev );
    ASSERT_CL_RETURN( ret );

    clFlush( queue );
    spinForEventsComplete( 1, &ev );

    t1.Stop();

    if( !quiet )
        tlog->Timer( "%32s  %lf s [ %8.2lf GB/s ]\n", "clEnqueueUnmapMemObject():", t1.GetElapsedTime(), nBytes, 1 );
}

const std::vector<cl_uint> AgentMover::getAgentCounts() const
{
    cl_int status;

    cl_uint* buffer = static_cast<cl_uint*> ( clEnqueueMapBuffer(context->queue,
                                                                 agentCounts,
                                                                 CL_TRUE,
                                                                 CL_MAP_READ,
                                                                 0,
                                                                 sizeof(cl_uint) * 8,
                                                                 0,
                                                                 NULL,
                                                                 NULL,
                                                                 &status) );
    CL_ERROR(status);

    std::vector<cl_uint> agentCountsVector(8);

    cl_uint i = 0;

    std::vector<cl_uint>::iterator iterator;

    for (iterator = agentCountsVector.begin(); iterator != agentCountsVector.end(); ++iterator)
    {
        *iterator = buffer[i];

        i++;
    }

    clEnqueueUnmapMemObject(context->queue, agentCounts, buffer, 0, NULL, NULL);

    return agentCountsVector;
}

void*
Alg::eval(std::vector<uint8_t>* pic, std::vector<uint8_t>* picprev){
  uint8_t* t = reinterpret_cast<uint8_t*>(pic->data());
  uint8_t* tp = reinterpret_cast<uint8_t*>(picprev->data());
  // Copy frame to the device
  float* result = (float*)clEnqueueMapBuffer(queue, clm_res, CL_FALSE, CL_MAP_READ, 0, 6*sizeof(cl_float), 0, NULL, NULL, &status);
  for (int i = 0; i < 6; i++) {
    result[i] = 0;
  }
  // Copy frame to the device
  status = clEnqueueWriteBuffer(queue, clm_pic, CL_FALSE, 0, cols * rows * sizeof(cl_uchar), t, 0, NULL, NULL);
  status = clEnqueueWriteBuffer(queue, clm_picprev, CL_FALSE, 0, cols * rows * sizeof(cl_uchar), tp, 0, NULL, NULL);
  status = clEnqueueWriteBuffer(queue, clm_res, CL_FALSE, 0, 6 * sizeof(float), result, 0, NULL, NULL);
  // Execute the OpenCL kernel on the list
  status = clEnqueueNDRangeKernel(queue, kern, 1, NULL, &global_threads, NULL, 0, NULL, NULL);
  status = clEnqueueReadBuffer(queue, clm_res, CL_FALSE, 0, 6*sizeof(float), result, 0, NULL, NULL);
  // Clean up and wait for all the comands to complete.
  status = clFlush(queue);
  status = clFinish(queue);
  for (int i = 0; i < 2; i++) {
    percentage[i] = result[i]*100.0 / (cols*rows);
  }
  for (int i = 0; i < 2; i++) {
    percentage[i + 2] = result[i + 2] / (cols*rows);
  }
  if (result[5])
    percentage[4] = result[4] / result[5];
  else
    percentage[4] = result[4] / 4;
  clEnqueueUnmapMemObject(queue, clm_res, result, 0, NULL, NULL);
  return percentage;
}

void mclUnmap(mclContext ctx, mclDeviceData dd, void* ptr)
{
  logOclCall("clEnqueueUnmapMemObject");
  cl_int ret;
  ret = clEnqueueUnmapMemObject(ctx.command_queue, dd.data, ptr, 0, 0, 0);
  MCL_VALIDATE(ret, "mclUnmap: Error unmapping data");
}

static void release_clobj(void)
{
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[gpu_id], pinned_result, cracked, 0, NULL, NULL), "Error Unmapping cracked");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[gpu_id], pinned_key, saved_key, 0, NULL, NULL), "Error Unmapping saved_key");
	HANDLE_CLERROR(clEnqueueUnmapMemObject(queue[gpu_id], pinned_idx, saved_idx, 0, NULL, NULL), "Error Unmapping saved_idx");
	HANDLE_CLERROR(clFinish(queue[gpu_id]), "Error releasing memory mappings");

	HANDLE_CLERROR(clReleaseMemObject(pinned_result), "Release pinned result buffer");
	HANDLE_CLERROR(clReleaseMemObject(pinned_key), "Release pinned key buffer");
	HANDLE_CLERROR(clReleaseMemObject(pinned_idx), "Release pinned index buffer");
	HANDLE_CLERROR(clReleaseMemObject(cl_salt), "Release salt buffer");
	HANDLE_CLERROR(clReleaseMemObject(cl_result), "Release result buffer");
	HANDLE_CLERROR(clReleaseMemObject(cl_saved_key), "Release key buffer");
	HANDLE_CLERROR(clReleaseMemObject(cl_saved_idx), "Release index buffer");
	HANDLE_CLERROR(clReleaseMemObject(cl_mid_key), "Release state buffer");
}

void*
Optzd::eval(std::vector<uint8_t>* t){
  cl_float* sh = (cl_float*)clEnqueueMapBuffer(queue, clm_sh, CL_FALSE, CL_MAP_WRITE, 0, 2*sizeof(cl_float), 0, NULL, NULL, &status);
  uint8_t* pic = reinterpret_cast<uint8_t*>(t->data());
  sh[0] = 0;
  sh[1] = 0;
  // Copy frame to the device
  status = clEnqueueWriteBuffer(queue, clm_pic, CL_TRUE, 0, cols * rows * sizeof(cl_uchar), pic, 0, NULL, NULL);
  status = clEnqueueWriteBuffer(queue, clm_sh, CL_TRUE, 0, 2 * sizeof(cl_float), sh, 0, NULL, NULL);
  // Execute the OpenCL kernel on the list
  status = clEnqueueNDRangeKernel(queue, kern, 1, NULL, &global_threads, NULL, 0, NULL, NULL);
  status = clEnqueueReadBuffer(queue, clm_sh, CL_TRUE, 0, 2*sizeof(float), sh, 0, NULL, NULL);
  // Clean up and wait for all the comands to complete.
  status = clFlush(queue);
  status = clFinish(queue);
  //eval-ing BS
  float shb = sh[1], shnb = sh[0];
  // for (int i = 0; i < (global_threads / 2); i++) {
  //   shb += sh[i*2];
  //   shnb += sh[(i*2)+1];
  // }
  
  clEnqueueUnmapMemObject(queue, clm_sh, sh, 0, NULL, NULL);
  if (shnb == 0) shnb = 4;
  *BS = shb/(shnb);
  return BS;
}

bool CL_Image3D::Unmap(const CL_CommandQueue* pCommandQueue, void** ppMappedData, CL_Event* pNewEvent, const CL_EventPool* pWaitList)
{
	CL_CPP_CONDITIONAL_RETURN_FALSE(!m_Image);
	CL_CPP_CONDITIONAL_RETURN_FALSE(!pCommandQueue);
	CL_CPP_CONDITIONAL_RETURN_FALSE(!ppMappedData);

	cl_uint uNumWaitEvents = pWaitList ? pWaitList->GetNumEvents() : 0;
	const cl_event* pWaitEvents = pWaitList ? pWaitList->GetEventPool() : NULL;
	cl_event NewEvent = NULL;

	//	Unmap a location in host memory from a buffer object.
	const cl_command_queue CommandQueue = pCommandQueue->GetCommandQueue();
	cl_int iErrorCode = clEnqueueUnmapMemObject(CommandQueue, m_Image, *ppMappedData, uNumWaitEvents, pWaitEvents, &NewEvent);

	CL_CPP_CATCH_ERROR(iErrorCode);
	CL_CPP_ON_ERROR_RETURN_FALSE(iErrorCode);

	(*ppMappedData) = NULL;

	if(NewEvent)
	{
		if(pNewEvent)
			pNewEvent->SetEvent(NewEvent);

		clReleaseEvent(NewEvent);
	}

	return true;
}

void init()
{
    int i, j;
    double t_start_init, t_end_init;

#ifndef ALOCACAO_NORMAL	
    t_start_init = rtclock();
    cl_float* data_input = (cl_float*)clEnqueueMapBuffer(clCommandQue, data_mem_obj, CL_TRUE, CL_MAP_WRITE, 0, sizeof(DATA_TYPE) * (M+1) * (N+1), 0, NULL, NULL, &errcode);
    t_end_init = rtclock();
    tmp_clEnqueueMapBuffer += t_end_init - t_start_init;
#endif


    t_start_init = rtclock();
    for (i = 0; i < M; i++)
    {
        for (j = 0; j < N; j++)
        {
            data[i*(N+1) + j] = ((DATA_TYPE) i*j) / M;
#ifndef ALOCACAO_NORMAL
            data_input[i*(N+1) + j] = ((DATA_TYPE) i*j)/ M;
#endif	
        }
    }
    t_end_init = rtclock();
    tmp_init += t_end_init - t_start_init;

#ifndef ALOCACAO_NORMAL
    t_start_init = rtclock();
    clEnqueueUnmapMemObject(clCommandQue, data_mem_obj, data_input, 0, NULL, NULL);
    t_end_init = rtclock();
    tmp_clEnqueueUnmapMemObject += t_end_init - t_start_init;
#endif
}