void xHer2k<cl_float2>::roundtrip_func() { timer.Start(timer_id); cl_int err; buffer_.A_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY, (buffer_.lda_ * buffer_.a_num_vectors_ + buffer_.offa_) * sizeof(cl_float2), NULL, &err); buffer_.B_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY, (buffer_.ldb_ * buffer_.b_num_vectors_ + buffer_.offb_) * sizeof(cl_float2), NULL, &err); buffer_.C_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE, (buffer_.ldc_ * buffer_.c_num_vectors_ + buffer_.offc_) * sizeof(cl_float2), NULL, &err); this->initialize_gpu_buffer(); clblasCher2k(order_, buffer_.uplo_, buffer_.transA_, buffer_.N_, buffer_.K_, buffer_.alpha_, buffer_.A_, buffer_.offa_, buffer_.lda_, buffer_.B_, buffer_.offb_, buffer_.ldb_, buffer_.beta_.s[0], buffer_.C_, buffer_.offc_, buffer_.ldc_, 1, &queue_, 0, NULL, NULL); err = clEnqueueWriteBuffer(queue_, buffer_.C_, CL_TRUE, buffer_.offc_ * sizeof(cl_float2), buffer_.ldc_ * buffer_.c_num_vectors_ * sizeof(cl_float2), buffer_.cpuC_, 0, NULL, &event_); clWaitForEvents(1, &event_); timer.Stop(timer_id); }
/** Perform Hermitian rank-2k update. \f$ C = \alpha A B^T + \alpha B A^T \beta C \f$ (trans == MagmaNoTrans), or \n \f$ C = \alpha A^T B + \alpha B^T A \beta C \f$ (trans == MagmaTrans), \n where \f$ C \f$ is Hermitian. @param[in] uplo Whether the upper or lower triangle of C is referenced. @param[in] trans Operation to perform on A and B. @param[in] n Number of rows and columns of C. n >= 0. @param[in] k Number of columns of A and B (for MagmaNoTrans) or rows of A and B (for MagmaTrans). k >= 0. @param[in] alpha Scalar \f$ \alpha \f$ @param[in] dA COMPLEX array on GPU device. If trans == MagmaNoTrans, the n-by-k matrix A of dimension (ldda,k), ldda >= max(1,n); \n otherwise, the k-by-n matrix A of dimension (ldda,n), ldda >= max(1,k). @param[in] ldda Leading dimension of dA. @param[in] dB COMPLEX array on GPU device. If trans == MagmaNoTrans, the n-by-k matrix B of dimension (lddb,k), lddb >= max(1,n); \n otherwise, the k-by-n matrix B of dimension (lddb,n), lddb >= max(1,k). @param[in] lddb Leading dimension of dB. @param[in] beta Scalar \f$ \beta \f$ @param[in,out] dC COMPLEX array on GPU device. The n-by-n Hermitian matrix C of dimension (lddc,n), lddc >= max(1,n). @param[in] lddc Leading dimension of dC. @ingroup magma_cblas3 */ extern "C" void magma_cher2k( magma_uplo_t uplo, magma_trans_t trans, magma_int_t n, magma_int_t k, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda, magmaFloatComplex_const_ptr dB, size_t dB_offset, magma_int_t lddb, float beta, magmaFloatComplex_ptr dC, size_t dC_offset, magma_int_t lddc, magma_queue_t queue ) { if (n <= 0 || k <= 0) return; cl_int err = clblasCher2k( clblasColumnMajor, clblas_uplo_const( uplo ), clblas_trans_const( trans ), n, k, alpha, dA, dA_offset, ldda, dB, dB_offset, lddb, beta, dC, dC_offset, lddc, 1, &queue, 0, NULL, g_event ); clFlush(queue); check_error( err ); }
void xHer2k<cl_float2>::call_func() { timer.Start(timer_id); clblasCher2k(order_, buffer_.uplo_, buffer_.transA_, buffer_.N_, buffer_.K_, buffer_.alpha_, buffer_.A_, buffer_.offa_, buffer_.lda_, buffer_.B_, buffer_.offb_, buffer_.ldb_, buffer_.beta_.s[0], buffer_.C_, buffer_.offc_, buffer_.ldc_, 1, &queue_, 0, NULL, &event_); clWaitForEvents(1, &event_); timer.Stop(timer_id); }
int main(void) { cl_int err; cl_platform_id platform = 0; cl_device_id device = 0; cl_context_properties props[3] = { CL_CONTEXT_PLATFORM, 0, 0 }; cl_context ctx = 0; cl_command_queue queue = 0; cl_mem bufA, bufC, bufB; cl_event event = NULL; int ret = 0; /* Setup OpenCL environment. */ err = clGetPlatformIDs(1, &platform, NULL); if (err != CL_SUCCESS) { printf( "clGetPlatformIDs() failed with %d\n", err ); return 1; } err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL); if (err != CL_SUCCESS) { printf( "clGetDeviceIDs() failed with %d\n", err ); return 1; } props[1] = (cl_context_properties)platform; ctx = clCreateContext(props, 1, &device, NULL, NULL, &err); if (err != CL_SUCCESS) { printf( "clCreateContext() failed with %d\n", err ); return 1; } queue = clCreateCommandQueue(ctx, device, 0, &err); if (err != CL_SUCCESS) { printf( "clCreateCommandQueue() failed with %d\n", err ); clReleaseContext(ctx); return 1; } /* Setup clblas. */ err = clblasSetup(); if (err != CL_SUCCESS) { printf("clblasSetup() failed with %d\n", err); clReleaseCommandQueue(queue); clReleaseContext(ctx); return 1; } /* Prepare OpenCL memory objects and place matrices inside them. */ bufA = clCreateBuffer(ctx, CL_MEM_READ_ONLY, N * K * sizeof(*A), NULL, &err); bufB = clCreateBuffer(ctx, CL_MEM_READ_ONLY, N * K * sizeof(*B), NULL, &err); bufC = clCreateBuffer(ctx, CL_MEM_READ_WRITE, N * N * sizeof(*C), NULL, &err); if ((bufA == NULL) || (bufC == NULL) || (bufB == NULL)) { printf("Failed to create buffern"); return 1; } err = clEnqueueWriteBuffer(queue, bufA, CL_TRUE, 0, N * K * sizeof(*A), A, 0, NULL, NULL); err = clEnqueueWriteBuffer(queue, bufB, CL_TRUE, 0, N * K * sizeof(*B), B, 0, NULL, NULL); err = clEnqueueWriteBuffer(queue, bufC, CL_TRUE, 0, N * N * sizeof(*C), C, 0, NULL, NULL); /* Call clblas function. */ err = clblasCher2k(order, uplo, transA, N, K, alpha, bufA, 0, lda, bufB, 0, ldb, beta, bufC, 0, ldc, 1, &queue, 0, NULL, &event); if (err != CL_SUCCESS) { printf("clblasCher2k() failed with %d\n", err); ret = 1; } else { /* Wait for calculations to be finished. */ err = clWaitForEvents(1, &event); /* Fetch results of calculations from GPU memory. */ err = clEnqueueReadBuffer(queue, bufC, CL_TRUE, 0, N * N * sizeof(*C), C, 0, NULL, NULL); /* At this point you will get the result of SSYRK placed in C array. */ printResult(); } /* Release OpenCL events. */ clReleaseEvent(event); /* Release OpenCL memory objects. */ clReleaseMemObject(bufC); clReleaseMemObject(bufB); clReleaseMemObject(bufA); /* Finalize work with clblas. */ clblasTeardown(); /* Release OpenCL working objects. */ clReleaseCommandQueue(queue); clReleaseContext(ctx); return ret; }