/** Perform Hermitian rank-1 update, \f$ A = \alpha x x^H + A \f$.
@param[in]
uplo Whether the upper or lower triangle of A is referenced.
@param[in]
n Number of rows and columns of A. n >= 0.
@param[in]
alpha Scalar \f$ \alpha \f$
@param[in]
dx COMPLEX array on GPU device.
The n element vector x of dimension (1 + (n-1)*incx).
@param[in]
incx Stride between consecutive elements of dx. incx != 0.
@param[in,out]
dA COMPLEX array of dimension (ldda,n), ldda >= max(1,n).
The n-by-n matrix A, on GPU device.
@param[in]
ldda Leading dimension of dA.
@ingroup magma_cblas2
*/
extern "C" void
magma_cher(
magma_uplo_t uplo,
magma_int_t n,
float alpha,
magmaFloatComplex_const_ptr dx, size_t dx_offset, magma_int_t incx,
magmaFloatComplex_ptr dA, size_t dA_offset, magma_int_t ldda,
magma_queue_t queue )
{
cl_int err = clblasCher(
clblasColumnMajor,
clblas_uplo_const( uplo ),
n,
alpha, dx, dx_offset, incx,
dA, dA_offset, ldda,
1, &queue, 0, NULL, g_event );
check_error( err );
}
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, bufX;
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_WRITE, N * lda * sizeof(cl_float2),
NULL, &err);
bufX = clCreateBuffer(ctx, CL_MEM_READ_ONLY, N * sizeof(cl_float2),
NULL, &err);
err = clEnqueueWriteBuffer(queue, bufA, CL_TRUE, 0,
N * lda * sizeof(cl_float2), A, 0, NULL, NULL);
err = clEnqueueWriteBuffer(queue, bufX, CL_TRUE, 0,
N * sizeof(cl_float2), X, 0, NULL, NULL);
err = clblasCher(order, uplo, N, alpha, bufX, 0 /*offx */, incx,
bufA, 0 /*offa */, lda, 1, &queue, 0, NULL, &event);
if (err != CL_SUCCESS) {
printf("clblasCher() 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, bufA, CL_TRUE, 0, (N * lda * sizeof(cl_float2)),
A, 0, NULL, NULL);
/* At this point you will get the result of CHER placed in A array. */
printResult();
}
/* Release OpenCL events. */
clReleaseEvent(event);
/* Release OpenCL memory objects. */
clReleaseMemObject(bufX);
clReleaseMemObject(bufA);
/* Finalize work with clblas. */
clblasTeardown();
/* Release OpenCL working objects. */
clReleaseCommandQueue(queue);
clReleaseContext(ctx);
return ret;
}