//
// FIXME: Report correct return value - Needs change in KPRINTF
//
static ssize_t
generator(
char *buf,
size_t buflen,
const struct SubproblemDim *subdims,
const struct PGranularity *pgran,
void *extra)
{
DUMMY_ARGS_USAGE_2(subdims, pgran);
CLBLASKernExtra *extraFlags = ( CLBLASKernExtra *)extra;
char tempTemplate[32*1024];
if ( buf == NULL) // return buffer size
{
buflen = (32 * 1024 * sizeof(char));
return (ssize_t)buflen;
}
#ifdef DEBUG_ROTMG
printf("dataType : %c\n", Prefix[extraFlags->dtype]);
#endif
strcpy( tempTemplate, (char*)rotmg_kernel );
kprintf kobj( Prefix[extraFlags->dtype], 1, false, false);
kobj.spit((char*)buf, tempTemplate);
return (32 * 1024 * sizeof(char));
}
//
// FIXME: Report correct return value - Needs change in KPRINTF
//
static ssize_t
generator(
char *buf,
size_t buflen,
const struct SubproblemDim *subdims,
const struct PGranularity *pgran,
void *extra)
{
DUMMY_ARGS_USAGE_2(pgran, subdims);
char tempTemplate[32*1024];
if ( buf == NULL) // return buffer size
{
buflen = (32 * 1024 * sizeof(char));
return (ssize_t)buflen;
}
CLBLASKernExtra *extraFlags = ( CLBLASKernExtra *)extra;
#ifdef DEBUG_AXPY
printf("AXPY GENERATOR called....\n");
printf("dataType : %c\n", Prefix[extraFlags->dtype]);
#endif
unsigned int vecLenA = extraFlags->vecLenA;
#ifdef DEBUG_AXPY
printf("Vector length used : %d\n\n", vecLenA);
#endif
bool doVLOAD = false;
if( extraFlags->flags & KEXTRA_NO_COPY_VEC_A )
{
doVLOAD = true;
#ifdef DEBUG_AXPY
printf("DOing VLOAD as Aligned Data Pointer not Availabe\n");
#endif
}
else
{
#ifdef DEBUG_AXPY
printf("Using Aligned Data Pointer .......\n");
#endif
}
strcpy( tempTemplate, (char*)axpy_kernel );
kprintf kobj( Prefix[extraFlags->dtype], vecLenA, doVLOAD, doVLOAD);
kobj.spit((char*)buf, tempTemplate);
return (32 * 1024 * sizeof(char));
}
void setup_buffer(int order_option, int side_option, int uplo_option,
int diag_option, int transA_option, int transB_option,
size_t M, size_t N, size_t K, size_t lda, size_t ldb,
size_t ldc, size_t offA, size_t offBX, size_t offCY,
double alpha, double beta)
{
DUMMY_ARGS_USAGE_4(side_option, diag_option, transB_option, M);
DUMMY_ARGS_USAGE_2(ldb, offBX);
initialize_scalars(alpha, beta);
buffer_.n_ = N;
buffer_.k_ = K;
buffer_.offA_ = offA;
buffer_.offC_ = offCY;
if (uplo_option == 0)
{
buffer_.uplo_ = clblasUpper;
}
else
{
buffer_.uplo_ = clblasLower;
}
if (ldc == 0)
{
buffer_.ldc_ = N;
}
else if (ldc < N)
{
std::cerr << "ldc:wrong size\n";
}
else
{
buffer_.ldc_ = ldc;
}
buffer_.c_num_vectors_ = N;
if (order_option == 0)
{
order_ = clblasRowMajor;
if (transA_option == 0)
{
buffer_.trans_a_ = clblasNoTrans;
buffer_.a_num_vectors_ = N;
if (lda == 0)
{
buffer_.lda_ = K;
}
else if (lda < K)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
else
{
buffer_.a_num_vectors_ = K;
if (transA_option == 1)
{
buffer_.trans_a_ = clblasTrans;
}
else if (transA_option == 2)
{
buffer_.trans_a_ = clblasConjTrans;
}
if (lda == 0)
{
buffer_.lda_ = N;
}
else if (lda < N)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
}
else
{
order_ = clblasColumnMajor;
if (transA_option == 0)
{
buffer_.a_num_vectors_ = K;
buffer_.trans_a_ = clblasNoTrans;
if (lda == 0)
{
buffer_.lda_ = N;
}
else if (lda < N)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
else
{
buffer_.a_num_vectors_ = N;
if (transA_option == 1)
{
buffer_.trans_a_ = clblasTrans;
}
else if (transA_option == 2)
{
buffer_.trans_a_ = clblasConjTrans;
}
if (lda == 0)
{
buffer_.lda_ = K;
}
else if (lda < K)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
}
buffer_.a_ = new T[buffer_.lda_*buffer_.a_num_vectors_];
buffer_.c_ = new T[buffer_.ldc_*buffer_.c_num_vectors_];
cl_int err;
buffer_.buf_a_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
(buffer_.lda_ * buffer_.a_num_vectors_ +
buffer_.offA_) * sizeof(T),
NULL, &err);
buffer_.buf_c_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
(buffer_.ldc_ * buffer_.c_num_vectors_ +
buffer_.offC_) * sizeof(T),
NULL, &err);
}
void setup_buffer(int order_option, int side_option, int uplo_option,
int diag_option, int transA_option, int transB_option,
size_t M, size_t N, size_t K, size_t lda, size_t ldb,
size_t ldc, size_t offA, size_t offBX, size_t offCY,
double alpha, double beta)
{
DUMMY_ARGS_USAGE_4(side_option, uplo_option, diag_option,
transB_option);
DUMMY_ARGS_USAGE_3(K, ldb, ldc);
DUMMY_ARGS_USAGE_2(offBX, offCY);
initialize_scalars(alpha, beta);
buffer_.m_ = M;
buffer_.n_ = N;
buffer_.offA_ = offA;
if (transA_option == 0)
{
buffer_.trans_a_ = clblasNoTrans;
buffer_.x_ = new T[buffer_.n_];
buffer_.y_ = new T[buffer_.m_];
}
else
{
buffer_.trans_a_ = clblasTrans;
buffer_.x_ = new T[buffer_.m_];
buffer_.y_ = new T[buffer_.n_];
}
if (order_option == 0)
{
order_ = clblasRowMajor;
buffer_.a_num_vectors_ = M;
if (lda == 0)
{
buffer_.lda_ = N;
}
else if (lda < N)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
else
{
order_ = clblasColumnMajor;
buffer_.a_num_vectors_ = N;
if (lda == 0)
{
buffer_.lda_ = M;
}
else if (lda < M)
{
std::cerr << "lda:wrong size\n";
exit(1);
}
else
{
buffer_.lda_ = lda;
}
}
buffer_.a_ = new T[buffer_.lda_*buffer_.a_num_vectors_];
cl_int err;
size_t size = (buffer_.lda_ * buffer_.a_num_vectors_ + buffer_.offA_) * sizeof(T);
if( size >= maxMemAllocSize )
throw std::runtime_error( "Tried to create a buffer larger than allowable on this device" );
buffer_.buf_a_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
size,
NULL, &err);
if (transA_option == 0)
{
buffer_.buf_x_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
buffer_.n_*sizeof(T),
NULL, &err);
buffer_.buf_y_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE,
buffer_.m_*sizeof(T),
NULL, &err);
}
else
{
buffer_.buf_x_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
buffer_.m_*sizeof(T),
NULL, &err);
buffer_.buf_y_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE,
buffer_.n_*sizeof(T),
NULL, &err);
}
}
void setup_buffer(int order_option, int side_option, int uplo_option,
int diag_option, int transA_option, int transB_option,
size_t M, size_t N, size_t K, size_t lda, size_t ldb,
size_t ldc, size_t offA, size_t offBX, size_t offCY,
double alpha, double beta)
{
DUMMY_ARGS_USAGE_3(transB_option, K, beta);
DUMMY_ARGS_USAGE_2(ldc, offCY);
initialize_scalars(alpha, beta);
buffer_.m_ = M;
buffer_.n_ = N;
buffer_.offA_ = offA;
buffer_.offB_ = offBX;
if (transA_option == 0)
{
buffer_.trans_a_ = clblasNoTrans;
}
else if (transA_option == 1)
{
buffer_.trans_a_ = clblasTrans;
}
else if (transA_option == 2)
{
buffer_.trans_a_ = clblasConjTrans;
}
if (side_option == 0)
{
buffer_.side_ = clblasLeft;
buffer_.a_num_vectors_ = M;
}
else
{
buffer_.side_ = clblasRight;
buffer_.a_num_vectors_ = N;
}
if (uplo_option == 0)
{
buffer_.uplo_ = clblasUpper;
}
else
{
buffer_.uplo_ = clblasLower;
}
if (diag_option == 0)
{
buffer_.diag_ = clblasUnit;
}
else
{
buffer_.diag_ = clblasNonUnit;
}
if (order_option == 0)
{
buffer_.order_ = clblasRowMajor;
buffer_.b_num_vectors_ = M;
if (ldb == 0)
{
buffer_.ldb_ = N;
}
else
{
if (ldb < N)
{
std::cerr << "ldb:wrong size\n";
exit(1);
}
else
{
buffer_.ldb_ = ldb;
}
}
}
else
{
buffer_.order_ = clblasColumnMajor;
buffer_.b_num_vectors_ = N;
if (ldb == 0)
{
buffer_.ldb_ = M;
}
else
{
if (ldb < M)
{
std::cerr << "ldb:wrong size\n";
exit(1);
}
else
{
buffer_.ldb_ = ldb;
}
}
}
if (lda == 0)
{
if (side_option == 0)
{
buffer_.lda_ = M;
}
else
{
buffer_.lda_ = N;
}
}
else
{
if( side_option == 0 && lda < M )
{
std::cerr << "ERROR: when side is 0, lda must be set to 0 "
"or a value >= M" << std::endl;
}
else if(side_option == 0 && lda >= M )
{
buffer_.lda_ = lda;
}
else if(side_option != 0 && lda < N)
{
std::cerr << "ERROR: when side is 1, lda must be set to 0 "
"or a value >= N" << std::endl;
}
else if (side_option != 0 && lda >= N)
{
buffer_.lda_ = lda;
}
}
buffer_.a_ = new T[buffer_.lda_*buffer_.a_num_vectors_];
buffer_.b_ = new T[buffer_.ldb_*buffer_.b_num_vectors_];
cl_int err;
buffer_.buf_a_ = clCreateBuffer(ctx_, CL_MEM_READ_ONLY,
(buffer_.lda_ * buffer_.a_num_vectors_ +
buffer_.offA_) * sizeof(T),
NULL, &err);
buffer_.buf_b_ = clCreateBuffer(ctx_, CL_MEM_READ_WRITE,
(buffer_.ldb_ * buffer_.b_num_vectors_ +
buffer_.offB_) * sizeof(T),
NULL, &err);
}
