void
gercCorrectnessTest(TestParams *params)
{
cl_int err;
T *A, *x, *y, *backA;
//size_t N, M;
T alpha_;
cl_mem bufA, bufx, bufy;
clMath::BlasBase *base;
cl_event *events;
// int ka, kxy;
base = clMath::BlasBase::getInstance();
if ((typeid(T) == typeid(cl_double) ||
typeid(T) == typeid(DoubleComplex)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
size_t lengthA;
if( params->order == clblasColumnMajor )
lengthA = params->N * params->lda;
else
lengthA = params->M * params->lda;
size_t lengthx = (1 + (((params->M)-1) * abs(params->incx)));
size_t lengthy = (1 + (((params->N)-1) * abs(params->incy)));
bool useAlpha = base->useAlpha();
if (useAlpha) {
alpha_ = convertMultiplier<T>(params->alpha);
}
A = new T[lengthA + params->offa];
x = new T[lengthx + params->offBX];
y = new T[lengthy + params->offCY];
backA = new T[lengthA + params->offa];
if((A == NULL) || (backA == NULL) || (x == NULL) || (y == NULL))
{
::std::cerr << "Cannot allocate memory on host side\n" << "!!!!!!!!!!!!Test skipped.!!!!!!!!!!!!" << ::std::endl;
deleteBuffers<T>(A, x, y, backA);
delete[] events;
SUCCEED();
return;
}
srand(params->seed);
int creationFlags = 0;
creationFlags = creationFlags | RANDOM_INIT;
creationFlags = ( (params-> order) == clblasRowMajor)? (creationFlags | ROW_MAJOR_ORDER) : (creationFlags);
BlasRoutineID BlasFn = CLBLAS_GER;
populate( (A + params->offa), params->M, params->N, params-> lda, BlasFn, creationFlags);
populate( (x + params->offBX), lengthx, 1, lengthx, BlasFn );
populate( (y + params->offCY), lengthy, 1, lengthy, BlasFn );
// Copy C to backX
memcpy(backA, A, (lengthA + params->offa) * sizeof(T));
// Allocate buffers
bufA = base->createEnqueueBuffer(A, (lengthA + params->offa) * sizeof(*A), 0, CL_MEM_READ_WRITE);
bufx = base->createEnqueueBuffer(x, (lengthx + params->offBX) * sizeof(*x), 0, CL_MEM_READ_ONLY);
bufy = base->createEnqueueBuffer(y, (lengthy + params->offCY) * sizeof(*y), 0, CL_MEM_READ_ONLY);
clblasOrder fOrder;
size_t fN, fM;
size_t fOffx, fOffy;
int fIncx, fIncy;
T *fX, *fY;
fOrder = params->order;
fM = params->M;
fN = params->N;
fIncx = params->incx;
fIncy = params->incy;
fX = x;
fY = y;
fOffx = params->offBX;
fOffy = params->offCY;
if (fOrder != clblasColumnMajor) {
doConjugate( (y + params->offCY), (1 + (params->N-1) * abs(params->incy)), 1, 1 );
fOrder = clblasColumnMajor;
fM = params->N;
fN = params->M;
fX = y;
fY = x;
fIncx = params->incy;
fIncy = params->incx;
fOffx = params->offCY;
fOffy = params->offBX;
// Note this according to the Legacy guide
clMath::blas::ger(fOrder, fM, fN, alpha_, fX , fOffx, fIncx, fY, fOffy, fIncy, A, params->offa, params->lda);
}
else {
clMath::blas::gerc(fOrder, fM, fN, alpha_, fX , fOffx, fIncx, fY, fOffy, fIncy, A, params->offa, params->lda);
}
if ((bufA == NULL) || (bufx == NULL) || (bufy == NULL)) {
/* Skip the test, the most probable reason is
* matrix too big for a device.
*/
releaseMemObjects(bufA, bufx, bufy);
deleteBuffers<T>(A, x, y, backA);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
err = (cl_int)::clMath::clblas::gerc( params->order, params->M, params->N, alpha_,
bufx, params->offBX, params->incx, bufy, params->offCY, params->incy,bufA, params->offa, params->lda,
params->numCommandQueues, base->commandQueues(), 0, NULL, events );
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufx, bufy);
deleteBuffers<T>(A, x, y, backA);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::GER() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues,
base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufx, bufy);
deleteBuffers<T>(A, x, y, backA);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
clEnqueueReadBuffer(base->commandQueues()[0], bufA, CL_TRUE, 0,
(lengthA + params->offa)* sizeof(*backA), backA, 0,
NULL, NULL);
releaseMemObjects(bufA, bufx, bufy);
// handle lda correctly based on row-major/col-major..
compareMatrices<T>(params->order, params->M , params->N, A+ params->offa, backA + params->offa, params->lda);
if (::testing::Test::HasFailure())
{
printTestParams(params->order, params->M, params->N, useAlpha,
base->alpha(),
params->lda, params->incx, params->incy, params->offa, params->offBX, params->offCY);
::std::cerr << "seed = " << params->seed << ::std::endl;
::std::cerr << "queues = " << params->numCommandQueues << ::std::endl;
}
deleteBuffers<T>(A, x, y, backA);
delete[] events;
}
void
gemmCorrectnessTest(TestParams *params)
{
cl_int err;
T *A, *B, *blasC, *clblasC;
T alpha, beta;
cl_mem bufA, bufB, bufC;
clMath::BlasBase *base;
bool useAlpha;
bool useBeta;
cl_event *events;
bool isComplex;
base = clMath::BlasBase::getInstance();
if ((typeid(T) == typeid(cl_double) ||
typeid(T) == typeid(DoubleComplex)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
isComplex = ((typeid(T) == typeid(FloatComplex)) ||
(typeid(T) == typeid(DoubleComplex)));
if (canCaseBeSkipped(params, isComplex)) {
std::cerr << ">> Test is skipped because it has no importance for this "
"level of coverage" << std::endl;
SUCCEED();
return;
}
useAlpha = base->useAlpha();
useBeta = base->useBeta();
alpha = ZERO<T>();
beta = ZERO<T>();
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
A = new T[params->rowsA * params->columnsA];
B = new T[params->rowsB * params->columnsB];
blasC = new T[params->rowsC * params->columnsC];
clblasC = new T[params->rowsC * params->columnsC];
srand(params->seed);
if (useAlpha) {
alpha = convertMultiplier<T>(params->alpha);
}
if (useBeta) {
beta = convertMultiplier<T>(params->beta);
}
//::std::cerr << "Generating input data... ";
randomGemmMatrices<T>(params->order, params->transA, params->transB,
params->M, params->N, params->K, useAlpha, &alpha, A, params->lda,
B, params->ldb, useBeta, &beta, blasC, params->ldc);
memcpy(clblasC, blasC, params->rowsC * params->columnsC * sizeof(*blasC));
//::std::cerr << "Done" << ::std::endl;
//::std::cerr << "Calling reference xGEMM routine... ";
if (params->order == clblasColumnMajor) {
::clMath::blas::gemm(clblasColumnMajor, params->transA, params->transB,
params->M, params->N, params->K, alpha, A,
params->lda, B, params->ldb, beta, blasC, params->ldc);
}
else {
T *reorderedA = new T[params->rowsA * params->columnsA];
T *reorderedB = new T[params->rowsB * params->columnsB];
T *reorderedC = new T[params->rowsC * params->columnsC];
reorderMatrix<T>(clblasRowMajor, params->rowsA, params->columnsA,
A, reorderedA);
reorderMatrix<T>(clblasRowMajor, params->rowsB, params->columnsB,
B, reorderedB);
reorderMatrix<T>(clblasRowMajor, params->rowsC, params->columnsC,
blasC, reorderedC);
::clMath::blas::gemm(clblasColumnMajor, params->transA, params->transB,
params->M, params->N, params->K, alpha, reorderedA,
params->rowsA, reorderedB, params->rowsB,
beta, reorderedC, params->rowsC);
reorderMatrix<T>(clblasColumnMajor, params->rowsC, params->columnsC,
reorderedC, blasC);
delete[] reorderedC;
delete[] reorderedB;
delete[] reorderedA;
}
//::std::cerr << "Done" << ::std::endl;
bufA = base->createEnqueueBuffer(A, params->rowsA * params->columnsA *
sizeof(*A), params->offA * sizeof(*A),
CL_MEM_READ_ONLY);
bufB = base->createEnqueueBuffer(B, params->rowsB * params->columnsB *
sizeof(*B), params->offBX * sizeof(*B),
CL_MEM_READ_ONLY);
bufC = base->createEnqueueBuffer(clblasC, params->rowsC * params->columnsC *
sizeof(*clblasC),
params->offCY * sizeof(*clblasC),
CL_MEM_READ_WRITE);
if ((bufA == NULL) || (bufB == NULL) || (bufC == NULL)) {
/* Skip the test, the most probable reason is
* matrix too big for a device.
*/
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
//::std::cerr << "Calling clblas xGEMM routine... ";
err = (cl_int)::clMath::clblas::gemm(params->order, params->transA,
params->transB, params->M, params->N, params->K, alpha, bufA,
params->offA, params->lda, bufB, params->offBX, params->ldb, beta,
bufC, params->offCY, params->ldc, params->numCommandQueues,
base->commandQueues(), 0, NULL, events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::GEMM() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues,
base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
//::std::cerr << "Done" << ::std::endl;
clEnqueueReadBuffer(base->commandQueues()[0], bufC, CL_TRUE,
params->offCY * sizeof(*clblasC),
params->rowsC * params->columnsC * sizeof(*clblasC),
clblasC, 0, NULL, NULL);
releaseMemObjects(bufA, bufB, bufC);
compareMatrices<T>(params->order, params->M, params->N, blasC, clblasC,
params->ldc);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
}
PROTO_THREAD_ROUTINE(app,argv)
{
vp_api_picture_t picture;
vp_api_io_pipeline_t pipeline;
vp_api_io_data_t out;
vp_api_io_stage_t stages[NB_STAGES];
vp_stages_input_file_config_t ifc;
vp_stages_output_sdl_config_t osc;
mjpeg_stage_decoding_config_t dec;
vp_os_memset(&ifc,0,sizeof(vp_stages_input_file_config_t));
ifc.name = ((char**)argv)[1];
ifc.buffer_size = (ACQ_WIDTH*ACQ_HEIGHT*3)/2;
osc.width = WINDOW_WIDTH;
osc.height = WINDOW_HEIGHT;
osc.bpp = 16;
osc.window_width = WINDOW_WIDTH;
osc.window_height = WINDOW_HEIGHT;
osc.pic_width = ACQ_WIDTH;
osc.pic_height = ACQ_HEIGHT;
osc.y_size = ACQ_WIDTH*ACQ_HEIGHT;
osc.c_size = (ACQ_WIDTH*ACQ_HEIGHT) >> 2;
/// Picture configuration
picture.format = PIX_FMT_YUV420P;
picture.width = ACQ_WIDTH;
picture.height = ACQ_HEIGHT;
picture.framerate = 15;
picture.y_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT );
picture.cr_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 );
picture.cb_buf = vp_os_malloc( ACQ_WIDTH*ACQ_HEIGHT/4 );
picture.y_line_size = ACQ_WIDTH;
picture.cb_line_size = ACQ_WIDTH / 2;
picture.cr_line_size = ACQ_WIDTH / 2;
picture.y_pad = 0;
picture.c_pad = 0;
dec.picture = &picture;
dec.out_buffer_size = 4096;
stages[0].type = VP_API_INPUT_FILE;
stages[0].cfg = (void *)&ifc;
stages[0].funcs = vp_stages_input_file_funcs;
stages[1].type = VP_API_FILTER_DECODER;
stages[1].cfg = (void *)&dec;
stages[1].funcs = mjpeg_decoding_funcs;
stages[2].type = VP_API_OUTPUT_SDL;
stages[2].cfg = (void *)&osc;
stages[2].funcs = vp_stages_output_sdl_funcs;
pipeline.nb_stages = NB_STAGES;
pipeline.stages = &stages[0];
vp_api_open(&pipeline, &pipeline_handle);
out.status = VP_API_STATUS_PROCESSING;
while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING))
{
vp_os_delay( 30 );
}
vp_api_close(&pipeline, &pipeline_handle);
return EXIT_SUCCESS;
}
void AK8973B::publish(short* data)
{
SUCCEED(ioctl(fd, ECS_IOCTL_SET_YPR, data) == 0);
}
AK8973B::~AK8973B() {
SUCCEED(close(fd) == 0);
}
DEFINE_THREAD_ROUTINE(video_stage, data)
{
C_RESULT res;
vp_api_io_pipeline_t pipeline;
vp_api_io_data_t out;
vp_api_io_stage_t stages[NB_STAGES];
vp_api_picture_t picture;
video_com_config_t icc;
vlib_stage_decoding_config_t vec;
vp_stages_yuv2rgb_config_t yuv2rgbconf;
#ifdef RECORD_VIDEO
video_stage_recorder_config_t vrc;
#endif
/// Picture configuration
picture.format = PIX_FMT_YUV420P;
picture.width = QVGA_WIDTH;
picture.height = QVGA_HEIGHT;
picture.framerate = 30;
picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT );
picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 );
picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 );
picture.y_line_size = QVGA_WIDTH;
picture.cb_line_size = QVGA_WIDTH / 2;
picture.cr_line_size = QVGA_WIDTH / 2;
vp_os_memset(&icc, 0, sizeof( icc ));
vp_os_memset(&vec, 0, sizeof( vec ));
vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf ));
icc.com = COM_VIDEO();
icc.buffer_size = 100000;
icc.protocol = VP_COM_UDP;
COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip);
vec.width = QVGA_WIDTH;
vec.height = QVGA_HEIGHT;
vec.picture = &picture;
vec.block_mode_enable = TRUE;
vec.luma_only = FALSE;
yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24;
#ifdef RECORD_VIDEO
vrc.fp = NULL;
#endif
pipeline.nb_stages = 0;
stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET;
stages[pipeline.nb_stages].cfg = (void *)&icc;
stages[pipeline.nb_stages].funcs = video_com_funcs;
pipeline.nb_stages++;
#ifdef RECORD_VIDEO
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void*)&vrc;
stages[pipeline.nb_stages].funcs = video_recorder_funcs;
pipeline.nb_stages++;
#endif // RECORD_VIDEO
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void*)&vec;
stages[pipeline.nb_stages].funcs = vlib_decoding_funcs;
pipeline.nb_stages++;
stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB;
stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf;
stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs;
pipeline.nb_stages++;
stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL;
stages[pipeline.nb_stages].cfg = NULL;
stages[pipeline.nb_stages].funcs = vp_stages_output_gtk_funcs;
pipeline.nb_stages++;
pipeline.stages = &stages[0];
/* Processing of a pipeline */
if( !ardrone_tool_exit() )
{
PRINT("\nVideo stage thread initialisation\n");
res = vp_api_open(&pipeline, &pipeline_handle);
if( SUCCEED(res) )
{
int loop = SUCCESS;
out.status = VP_API_STATUS_PROCESSING;
while( !ardrone_tool_exit() && (loop == SUCCESS) )
{
if( SUCCEED(vp_api_run(&pipeline, &out)) ) {
if( (out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING) ) {
loop = SUCCESS;
}
}
else loop = -1; // Finish this thread
}
// This call is crashing everything. The crash is inside the closure of the VP packetizer. It looks like a Parrot bug.
// vp_api_close(&pipeline, &pipeline_handle);
}
}
PRINT("Video stage thread ended\n");
return (THREAD_RET)0;
}
/* Test case to test for graceful handling of corrupted input.
* NOTE: The test case is considered a "success" as long as the corrupted
* file was successfully generated and the test case runs without a segfault.
*/
TEST_F(TestZipFile, CorruptedFile)
{
XFILE::CFile *file;
char buf[16];
memset(&buf, 0, sizeof(buf));
CStdString reffilepath, strzippath, strpathinzip, str;
CFileItemList itemlist;
unsigned int size, i;
int64_t count = 0;
reffilepath = XBMC_REF_FILE_PATH("xbmc/filesystem/test/reffile.txt.zip");
ASSERT_TRUE((file = XBMC_CREATECORRUPTEDFILE(reffilepath, ".zip")) != NULL);
std::cout << "Reference file generated at '" << XBMC_TEMPFILEPATH(file) << "'" << std::endl;
URIUtils::CreateArchivePath(strzippath, "zip", XBMC_TEMPFILEPATH(file), "");
if (!XFILE::CDirectory::GetDirectory(strzippath, itemlist, "",
XFILE::DIR_FLAG_NO_FILE_DIRS))
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
if (itemlist.IsEmpty())
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
strpathinzip = itemlist[0]->GetPath();
if (!file->Open(strpathinzip))
{
XBMC_DELETETEMPFILE(file);
SUCCEED();
return;
}
std::cout << "file->GetLength(): " <<
testing::PrintToString(file->GetLength()) << std::endl;
std::cout << "file->Seek(file->GetLength() / 2, SEEK_CUR) return value: " <<
testing::PrintToString(file->Seek(file->GetLength() / 2, SEEK_CUR)) << std::endl;
std::cout << "file->Seek(0, SEEK_END) return value: " <<
testing::PrintToString(file->Seek(0, SEEK_END)) << std::endl;
std::cout << "file->Seek(0, SEEK_SET) return value: " <<
testing::PrintToString(file->Seek(0, SEEK_SET)) << std::endl;
std::cout << "File contents:" << std::endl;
while ((size = file->Read(buf, sizeof(buf))) > 0)
{
str.Format(" %08X", count);
std::cout << str << " ";
count += size;
for (i = 0; i < size; i++)
{
str.Format("%02X ", buf[i]);
std::cout << str;
}
while (i++ < sizeof(buf))
std::cout << " ";
std::cout << " [";
for (i = 0; i < size; i++)
{
if (buf[i] >= ' ' && buf[i] <= '~')
std::cout << buf[i];
else
std::cout << ".";
}
std::cout << "]" << std::endl;
}
file->Close();
XBMC_DELETETEMPFILE(file);
}
static C_RESULT skip_line(FILE* f)
{
while( !is_eol(next_c) && SUCCEED(fetch_char(f)) );
return C_OK;
}
void
tpmvCorrectnessTest(TestParams *params)
{
cl_int err;
T *AP, *blasX, *clblasX;
cl_mem bufAP, bufX, bufXTemp;
clMath::BlasBase *base;
cl_event *events;
base = clMath::BlasBase::getInstance();
if ((typeid(T) == typeid(cl_double) ||
typeid(T) == typeid(DoubleComplex)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
printf("number of command queues : %d\n\n", params->numCommandQueues);
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
size_t lengthAP = (params->N *( params->N + 1 ))/2 ;
size_t lengthX = (1 + ((params->N -1) * abs(params->incx)));
AP = new T[lengthAP + params->offa ];
blasX = new T[lengthX + params->offBX ];
clblasX = new T[lengthX + params->offBX ];
if((AP == NULL) || (blasX == NULL) || (clblasX == NULL))
{
::std::cerr << "Cannot allocate memory on host side\n" << "!!!!!!!!!!!!Test skipped.!!!!!!!!!!!!" << ::std::endl;
deleteBuffers<T>(AP, blasX, clblasX);
delete[] events;
SUCCEED();
return;
}
srand(params->seed);
::std::cerr << "Generating input data... ";
// Set data in A and X using populate() routine
int creationFlags = 0;
creationFlags = creationFlags | RANDOM_INIT | PACKED_MATRIX;
// Default is Column-Major
creationFlags = ( (params-> order) == clblasRowMajor)? (creationFlags | ROW_MAJOR_ORDER) : (creationFlags);
creationFlags = ( (params-> uplo) == clblasLower)? (creationFlags | LOWER_HALF_ONLY) : (creationFlags | UPPER_HALF_ONLY);
BlasRoutineID BlasFn = CLBLAS_TRMV;
// Populate A and blasX
populate( AP + params->offa, params-> N, params-> N, 0, BlasFn, creationFlags);
populate( blasX , (lengthX + params->offBX), 1, (lengthX + params->offBX), BlasFn);
// Copy blasX to clblasX
memcpy(clblasX, blasX, (lengthX + params->offBX)* sizeof(*blasX));
::std::cerr << "Done" << ::std::endl;
// Allocate buffers
bufAP = base->createEnqueueBuffer(AP, (lengthAP + params->offa)* sizeof(*AP), 0, CL_MEM_READ_ONLY);
bufX = base->createEnqueueBuffer(clblasX, (lengthX + params->offBX)* sizeof(*clblasX), 0, CL_MEM_WRITE_ONLY);
bufXTemp = base->createEnqueueBuffer(NULL, lengthX * sizeof(*clblasX), 0, CL_MEM_READ_ONLY);
//printData( "bufX", blasX, lengthX, 1, lengthX);
//printData( "clblasX", clblasX, lengthX, 1, lengthX);
::std::cerr << "Calling reference xTPMV routine... ";
clblasOrder order;
clblasUplo fUplo;
clblasTranspose fTrans;
order = params->order;
fUplo = params->uplo;
fTrans = params->transA;
if (order != clblasColumnMajor)
{
order = clblasColumnMajor;
fUplo = (params->uplo == clblasUpper)? clblasLower : clblasUpper;
fTrans = (params->transA == clblasNoTrans)? clblasTrans : clblasNoTrans;
if( params->transA == clblasConjTrans )
doConjugate( (AP +params->offa), (( params->N * (params->N + 1)) / 2) , 1, 1 );
}
::clMath::blas::tpmv( order, fUplo, fTrans, params->diag, params->N, AP, params->offa, blasX, params->offBX, params->incx);
::std::cerr << "Done" << ::std::endl;
// Hold X vector
if ((bufAP == NULL) || (bufX == NULL) || (bufXTemp == NULL)) {
/* Skip the test, the most probable reason is
* matrix too big for a device.
*/
releaseMemObjects(bufAP, bufX, bufXTemp);
deleteBuffers<T>(AP, blasX, clblasX);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
::std::cerr << "Calling clblas xTPMV routine... ";
DataType type;
type = ( typeid(T) == typeid(cl_float))? TYPE_FLOAT : ( typeid(T) == typeid(cl_double))? TYPE_DOUBLE: ( typeid(T) == typeid(cl_float2))? TYPE_COMPLEX_FLOAT:TYPE_COMPLEX_DOUBLE;
// Should use bufXTemp as well
err = (cl_int)::clMath::clblas::tpmv( type, params->order, params->uplo, params->transA, params->diag, params->N, bufAP,
params->offa, bufX, params->offBX, params->incx, bufXTemp, params->numCommandQueues, base->commandQueues(),
0, NULL, events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufAP, bufX, bufXTemp);
deleteBuffers<T>(AP, blasX, clblasX);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::TPMV() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues,
base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufAP, bufX, bufXTemp);
deleteBuffers<T>(AP, blasX, clblasX);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
::std::cerr << "Done" << ::std::endl;
err = clEnqueueReadBuffer(base->commandQueues()[0], bufX, CL_TRUE, 0,
(lengthX + params->offBX) * sizeof(*clblasX), clblasX, 0,
NULL, NULL);
if (err != CL_SUCCESS)
{
::std::cerr << "TPMV: Reading results failed...." << std::endl;
}
releaseMemObjects(bufAP, bufX, bufXTemp);
compareMatrices<T>(clblasColumnMajor, lengthX , 1, (blasX + params->offBX), (clblasX + params->offBX),
lengthX);
deleteBuffers<T>(AP, blasX, clblasX);
delete[] events;
}
int main(void)
{
com_config_t config;
vp_com_connection_t connection;
config.connection = VP_COM_WIFI;
config.localAdapterName = "rausb0";
connection.essid = "Drone";
connection.channel = 10;
if(FAILED(com_init(&config)))
PRINT("com_init failed\n");
if(FAILED(com_passKey("9F1C3EE11CBA230B27BF1C1B6F")))
PRINT("com_passKey failed\n");
if(FAILED(com_connect(&connection,1)))
PRINT("com_connect failed\n");
clt.socket = VP_COM_CLIENT;
clt.port = DRONE_PORT;
clt.serverHost = DRONE_HOST;
if(SUCCEED(com_open(&clt,&my_read,&my_write)))
{
int32_t i = 0;
float st = timeGetTime();
float et = timeGetTime();
float db = 0.0f;
float d = 0.0f;
for(i=0; i < TIME_TO_SEND;i++)
{
int32_t received;
PRINT("\r reception n° %d... ",i);
received = 0;
size = SIZE_TO_SEND;
while(received != SIZE_TO_SEND)
{
my_read(&clt,buffer,&size);
received += size;
size = SIZE_TO_SEND - received;
}
PRINT("%d bytes ",received);
}
et = timeGetTime();
d = (et - st) / 1000.0f;
if(d > 0)
{
float tx = SIZE_TO_SEND * TIME_TO_SEND / 1024.0f;
db = tx / d;
}
PRINT("\n---------------\n");
PRINT("Start Time : %f\n",st);
PRINT("End Time : %f\n",et);
PRINT("%d Kbytes sent in %f time\n",SIZE_TO_SEND * TIME_TO_SEND / 1024,d);
PRINT("Debit: %f\n",db);
PRINT("\n---------------\n");
}
else
{
PRINT("snif... pas connecte a la socket\n");
}
PRINT("Waiting for disconnection\n");
vp_delay(5000);
com_disconnect();
PRINT("Disconnected\n");
com_shutdown();
return 0;
}
TEST_F(InitializationOfAVector, SuccessfullyExecutes) {
SystemErr eIgnore = S_E_CLEAR;
initVector(&v, 1, NULL, NULL, &eIgnore);
SUCCEED();
}
// 直接返回成功 失败
TEST(casename, testname5)
{
SUCCEED();
ADD_FAILURE();
}
DEFINE_THREAD_ROUTINE(drone_video_stage_thread, data)
{
PIPELINE_HANDLE pipeline_handle;
printf("Vision thread started\n");
C_RESULT res;
vp_api_io_pipeline_t pipeline;
vp_api_io_data_t out;
vp_api_io_stage_t stages[DRONE_NB_STAGES];
vp_api_picture_t picture;
video_com_config_t icc;
vlib_stage_decoding_config_t vec;
vp_stages_yuv2rgb_config_t yuv2rgbconf;
/// Picture configuration
picture.format = PIX_FMT_YUV420P;
picture.width = QVGA_WIDTH;
picture.height = QVGA_HEIGHT;
picture.framerate = 30;
picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT );
picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 );
picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 );
picture.y_line_size = QVGA_WIDTH;
picture.cb_line_size = QVGA_WIDTH / 2;
picture.cr_line_size = QVGA_WIDTH / 2;
vp_os_memset(&icc, 0, sizeof( icc ));
vp_os_memset(&vec, 0, sizeof( vec ));
vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf ));
icc.com = COM_VIDEO();
icc.buffer_size = 100000;
icc.protocol = VP_COM_UDP;
COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip);
vec.width = QVGA_WIDTH;
vec.height = QVGA_HEIGHT;
vec.picture = &picture;
vec.block_mode_enable = TRUE;
vec.luma_only = FALSE;
yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24;
pipeline.nb_stages = 0;
stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET;
stages[pipeline.nb_stages].cfg = (void *)&icc;
stages[pipeline.nb_stages].funcs = video_com_funcs;
pipeline.nb_stages++;
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void*)&vec;
stages[pipeline.nb_stages].funcs = vlib_decoding_funcs;
pipeline.nb_stages++;
stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB;
stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf;
stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs;
pipeline.nb_stages++;
stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL;
stages[pipeline.nb_stages].cfg = NULL;
stages[pipeline.nb_stages].funcs = vp_video_output_funcs;
pipeline.nb_stages++;
pipeline.stages = &stages[0];
pthread_mutex_lock(&drone_sharedDataMutex);
int doRun = drone_doRun;
pthread_mutex_unlock(&drone_sharedDataMutex);
/* Processing of a pipeline */
if (doRun) {
res = 0;
res = vp_api_open(&pipeline, &pipeline_handle);
if (SUCCEED(res)) {
int loop = SUCCESS;
out.status = VP_API_STATUS_PROCESSING;
while (doRun && (loop == SUCCESS)) {
pthread_mutex_lock(&drone_sharedDataMutex);
doRun = drone_doRun;
pthread_mutex_unlock(&drone_sharedDataMutex);
if( SUCCEED(vp_api_run(&pipeline, &out)) ) {
if ((out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) {
loop = SUCCESS;
}
}
}
fprintf(stderr, "BUG and WORKAROUND: vp_api_close was never called because it is buggy\n");
// vp_api_close(&pipeline, &pipeline_handle); // <- TODO: do not call this - fix this function in SDK
}
}
vp_os_free(picture.y_buf);
vp_os_free(picture.cr_buf);
vp_os_free(picture.cb_buf);
printf("Vision thread terminated\n");
return (THREAD_RET) 0;
}
void
her2kCorrectnessTest(TestParams *params)
{
cl_int err;
T *A, *B, *blasC, *clblasC;
T alpha, beta;
cl_mem bufA, bufC, bufB;
clMath::BlasBase *base;
cl_event *events;
if (params->transA == clblasTrans) {
::std::cerr << ">> her2k(TRANSPOSE) for complex numbers "
"is not allowed." << ::std::endl <<
">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
base = clMath::BlasBase::getInstance();
if ((typeid(T) == typeid(cl_double) ||
typeid(T) == typeid(DoubleComplex)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
A = new T[params->rowsA * params->columnsA];
B = new T[params->rowsB * params->columnsB];
blasC = new T[params->rowsC * params->columnsC];
clblasC = new T[params->rowsC * params->columnsC];
if((A == NULL) || (B == NULL) || (blasC == NULL) || (clblasC == NULL))
{
deleteBuffers<T>(A, B, blasC, clblasC);
::std::cerr << "Cannot allocate memory on host side\n" << "!!!!!!!!!!!!Test skipped.!!!!!!!!!!!!" << ::std::endl;
delete[] events;
SUCCEED();
return;
}
srand(params->seed);
alpha = convertMultiplier<T>(params->alpha);
beta = convertMultiplier<T>(params->beta);
::std::cerr << "Generating input data... ";
clblasTranspose ftransB = (params->transA==clblasNoTrans)? clblasConjTrans: clblasNoTrans;
randomGemmMatrices<T>(params->order, params->transA, ftransB,
params->N, params->N, params->K, true, &alpha, A, params->lda,
B, params->ldb, true, &beta, blasC, params->ldc);
memcpy(clblasC, blasC, params->rowsC * params->columnsC * sizeof(*blasC));
::std::cerr << "Done" << ::std::endl;
bufA = base->createEnqueueBuffer(A, params->rowsA * params->columnsA * sizeof(*A), params->offA * sizeof(*A),
CL_MEM_READ_ONLY);
bufB = base->createEnqueueBuffer(B, params->rowsB * params->columnsB * sizeof(*B), params->offBX * sizeof(*B),
CL_MEM_READ_ONLY);
bufC = base->createEnqueueBuffer(clblasC, params->rowsC * params->columnsC * sizeof(*clblasC),
params->offCY * sizeof(*clblasC),
CL_MEM_READ_WRITE);
if ((bufA == NULL) || (bufB == NULL)|| (bufC == NULL)) {
/* Skip the test, the most probable reason is
* matrix too big for a device.
*/
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
::std::cerr << "Calling reference xHER2K routine... ";
T fAlpha = alpha;
if (params->order == clblasColumnMajor) {
::clMath::blas::her2k(clblasColumnMajor, params->uplo, params->transA,
params->N, params->K, fAlpha, A, 0, params->lda, B, 0, params->ldb,
CREAL(beta), blasC, 0, params->ldc);
}
else {
CIMAG( fAlpha ) *= -1.0; // According to netlib C- interface
clblasTranspose fTransA = (params->transA == clblasNoTrans) ? clblasConjTrans : clblasNoTrans;
clblasUplo fUplo = (params->uplo == clblasUpper) ? clblasLower : clblasUpper;
::clMath::blas::her2k(clblasColumnMajor, fUplo, fTransA, params->N, params->K, fAlpha,
A, 0, params->lda, B, 0, params->ldb, CREAL(beta), blasC, 0, params->ldc);
}
::std::cerr << "Done" << ::std::endl;
::std::cerr << "Calling clblas xHER2K routine... ";
err = (cl_int)::clMath::clblas::her2k(params->order, params->uplo,
params->transA, params->N, params->K,
alpha, bufA, params->offA, params->lda, bufB, params->offBX, params->ldb,
CREAL(beta), bufC, params->offCY,
params->ldc, params->numCommandQueues,
base->commandQueues(), 0, NULL,
events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::HER2K() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues,
base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufB, bufC);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
::std::cerr << "Done" << ::std::endl;
clEnqueueReadBuffer(base->commandQueues()[0], bufC, CL_TRUE, params->offCY * sizeof(*clblasC),
params->rowsC * params->columnsC * sizeof(*clblasC), clblasC, 0, NULL, NULL);
releaseMemObjects(bufA, bufB, bufC);
compareMatrices<T>(params->order, params->N, params->N, blasC, clblasC, params->ldc);
deleteBuffers<T>(A, B, blasC, clblasC);
delete[] events;
}
/** 显示返回成功或失败
| Fatal assertion | Nonfatal assertion |
|-----------------+--------------------|
| FAIL(); | ADD_FAILURE(); |
|-----------------+--------------------|
直接返回成功: SUCCEED();
*/
TEST(Lesson2, section3)
{
ADD_FAILURE() << "Sorry"; // None Fatal Asserton，继续往下执行。
//FAIL(); // Fatal Assertion，不往下执行该案例。
SUCCEED();
}
int main(int argc, char **argv)
{
vp_api_picture_t video_picture;
vp_api_picture_t buffer_blockline;
#ifdef BLOCK_MODE
vp_api_picture_t video_blockline;
#endif
vp_api_io_pipeline_t pipeline;
vp_api_io_data_t out;
vp_api_io_stage_t stages[NB_STAGES_MAX];
vp_os_memset(&ivc,0,sizeof(ivc));
vp_os_memset(&ofc,0,sizeof(ofc));
vp_os_memset(&occ,0,sizeof(occ));
// CAMIF config
ivc.camera = "/dev/video1";
ivc.i2c = "/dev/i2c-0";
#ifdef OV_CAM
ivc.camera_configure = &camera_configure_ov77xx;
#else
#ifdef CRESYN_CAM
ivc.camera_configure = &camera_configure_cresyn;
#else
#error no cam selected
#endif
#endif
ivc.resolution = VGA;
ivc.nb_buffers = 8;
ivc.format = V4L2_PIX_FMT_YUV420;
ivc.y_pad = 0;
ivc.c_pad = 0;
ivc.offset_delta = 0;
#ifdef BLOCK_MODE
ivc.vp_api_blockline = &video_blockline;
#endif
ivc.vp_api_picture = &video_picture;
ivc.use_chrominances = 1;
ivc.framerate = 15;
// BUFFER
#ifdef BLOCK_MODE
bbc.picture = &video_blockline;
#endif
// ENCODER
vec.width = 320;
vec.height = 240;
#ifdef BLOCK_MODE
vec.block_mode_enable = TRUE;
#else
vec.block_mode_enable = FALSE;
#endif
vec.picture = &video_picture;
// OUTPUT FILE config
ofc.name = "/tmp/out.yuv";
// COM CONFIG
occ.com = wired_com();
occ.config = wired_config();
occ.connection = wired_connection();
occ.socket.type = VP_COM_SERVER;
occ.socket.protocol = VP_COM_TCP;
occ.socket.port = 5555;
occ.buffer_size = 640*480*3/2;
// build pipeline
pipeline.nb_stages = 0;
stages[pipeline.nb_stages].type = VP_API_INPUT_CAMIF;
stages[pipeline.nb_stages].cfg = (void *)&ivc;
stages[pipeline.nb_stages++].funcs = V4L2_funcs;
#ifdef BLOCK_MODE
#ifdef BUFFER
stages[pipeline.nb_stages].type = VP_API_INPUT_CAMIF;
stages[pipeline.nb_stages].cfg = (void *)&bbc;
stages[pipeline.nb_stages++].funcs = blockline_to_buffer_funcs;
#endif
#endif
#ifdef ENCODE
stages[pipeline.nb_stages].type = VP_API_FILTER_ENCODER;
stages[pipeline.nb_stages].cfg = (void*)&vec;
stages[pipeline.nb_stages++].funcs = vlib_encoding_funcs;
#endif
#ifdef FILE_OUTPUT
stages[pipeline.nb_stages].type = VP_API_OUTPUT_FILE;
stages[pipeline.nb_stages].cfg = (void *)&ofc;
stages[pipeline.nb_stages++].funcs = vp_stages_output_file_funcs;
#endif
#ifdef ETHERNET_OUTPUT
stages[pipeline.nb_stages].type = VP_API_OUTPUT_SOCKET;
stages[pipeline.nb_stages].cfg = (void *)&occ;
stages[pipeline.nb_stages++].funcs = vp_stages_output_com_funcs;
#endif
pipeline.stages = &stages[0];
// launch pipelines
vp_api_open(&pipeline, &pipeline_handle);
out.status = VP_API_STATUS_PROCESSING;
/////////////////////////////////////////////////////////////////////////////////////////
uint16_t i = 0;
struct timeval time1,time2;
printf("Pipeline launched....\n");
gettimeofday(&time1,NULL);
while(SUCCEED(vp_api_run(&pipeline, &out)) && (out.status == VP_API_STATUS_PROCESSING))
{
i++;
//printf("image %d \n",i);
if (i>50)
break;
//vp_os_delay(20);
}
/////////////////////////////////////////////////////////////////////////////////////////
gettimeofday(&time2,NULL);
int seconde = time2.tv_sec-time1.tv_sec;
int ms = time2.tv_usec-time1.tv_usec;
if (ms<0)
{
seconde--;
ms += 1000000;
}
ms = ms/1000;
float fps = ((float)i*1000)/(float)(seconde*1000+ms);
printf("temps ecoule : %d.%d / nombre image : %d average fps : %f\n",seconde,ms,i,fps);
vp_api_close(&pipeline, &pipeline_handle);
return EXIT_SUCCESS;
}
DEFINE_THREAD_ROUTINE(app_main, data)
{
C_RESULT res = C_FAIL;
vp_com_wifi_config_t* config = NULL;
JNIEnv* env = NULL;
if (g_vm) {
(*g_vm)->AttachCurrentThread (g_vm, (JNIEnv **) &env, NULL);
}
bContinue = TRUE;
mobile_main_param_t *param = data;
video_recorder_thread_param_t video_recorder_param;
video_recorder_param.priority = VIDEO_RECORDER_THREAD_PRIORITY;
video_recorder_param.finish_callback = param->academy_download_callback_func;
vp_os_memset(&ardrone_info, 0x0, sizeof(ardrone_info_t));
while ((config = (vp_com_wifi_config_t *)wifi_config()) != NULL && strlen(config->itfName) == 0)
{
//Waiting for wifi initialization
vp_os_delay(250);
if (ardrone_tool_exit() == TRUE) {
if (param != NULL && param->callback != NULL) {
param->callback(env, param->obj, ARDRONE_MESSAGE_DISCONNECTED);
}
return 0;
}
}
vp_os_memcpy(&ardrone_info.drone_address[0], config->server, strlen(config->server));
while (-1 == getDroneVersion (param->root_dir, &ardrone_info.drone_address[0], &ardroneVersion))
{
LOGD (TAG, "Getting AR.Drone version");
vp_os_delay (250);
}
sprintf(&ardrone_info.drone_version[0], "%u.%u.%u", ardroneVersion.majorVersion, ardroneVersion.minorVersion, ardroneVersion.revision);
LOGD (TAG, "ARDrone Version : %s\n", &ardrone_info.drone_version[0]);
LOGI(TAG, "Drone Family: %d", ARDRONE_VERSION());
res = ardrone_tool_setup_com( NULL );
if( FAILED(res) )
{
LOGII("Setup com failed");
LOGW(TAG, "Wifi initialization failed. It means either:");
LOGW(TAG, "\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n");
LOGW(TAG, "\t* wifi device is not present (on your pc or on your card)\n");
LOGW(TAG, "\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n");
LOGW(TAG, "\t* ap is not up (reboot card or remove wifi usb dongle)\n");
LOGW(TAG, "\t* wifi device has no antenna\n");
if (param != NULL && param->callback != NULL) {
param->callback(env, param->obj, ARDRONE_MESSAGE_ERR_NO_WIFI);
}
}
else
{
LOGII("ardrone_tool_setup_com [OK]");
#define NB_IPHONE_PRE_STAGES 0
#define NB_IPHONE_POST_STAGES 2
//Alloc structs
specific_parameters_t * params = (specific_parameters_t *)vp_os_calloc(1, sizeof(specific_parameters_t));
specific_stages_t * iphone_pre_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t));
specific_stages_t * iphone_post_stages = (specific_stages_t*)vp_os_calloc(1, sizeof(specific_stages_t));
vp_api_picture_t * in_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t));
vp_api_picture_t * out_picture = (vp_api_picture_t*) vp_os_calloc(1, sizeof(vp_api_picture_t));
in_picture->width = STREAM_WIDTH;
in_picture->height = STREAM_HEIGHT;
out_picture->framerate = 20;
out_picture->format = PIX_FMT_RGB565;
out_picture->width = STREAM_WIDTH;
out_picture->height = STREAM_HEIGHT;
out_picture->y_buf = vp_os_malloc( STREAM_WIDTH * STREAM_HEIGHT * 2 );
out_picture->cr_buf = NULL;
out_picture->cb_buf = NULL;
out_picture->y_line_size = STREAM_WIDTH * 2;
out_picture->cb_line_size = 0;
out_picture->cr_line_size = 0;
//Define the list of stages size
iphone_pre_stages->length = NB_IPHONE_PRE_STAGES;
iphone_post_stages->length = NB_IPHONE_POST_STAGES;
//Alloc the lists
iphone_pre_stages->stages_list = NULL;
iphone_post_stages->stages_list = (vp_api_io_stage_t*)vp_os_calloc(iphone_post_stages->length,sizeof(vp_api_io_stage_t));
//Fill the POST-stages------------------------------------------------------
int postStageNumber = 0;
vp_os_memset (&vlat, 0x0, sizeof (vlat));
vlat.state = 0;
vlat.last_decoded_frame_info= (void *)&vec;
iphone_post_stages->stages_list[postStageNumber].type = VP_API_FILTER_DECODER;
iphone_post_stages->stages_list[postStageNumber].cfg = (void *)&vlat;
iphone_post_stages->stages_list[postStageNumber++].funcs = vp_stages_latency_estimation_funcs;
vp_os_memset (&ovsc, 0x0, sizeof (ovsc));
ovsc.video_decoder = &vec;
iphone_post_stages->stages_list[postStageNumber].type = VP_API_OUTPUT_LCD;
iphone_post_stages->stages_list[postStageNumber].cfg = (void *)&ovsc;
iphone_post_stages->stages_list[postStageNumber++].funcs = opengl_video_stage_funcs;
params->in_pic = in_picture;
params->out_pic = out_picture;
params->pre_processing_stages_list = iphone_pre_stages;
params->post_processing_stages_list = iphone_post_stages;
#if USE_THREAD_PRIORITIES
params->needSetPriority = 1;
params->priority = VIDEO_THREAD_PRIORITY;
#else
params->needSetPriority = 0;
params->priority = 0;
#endif
START_THREAD(video_stage, params);
if (IS_LEAST_ARDRONE2)
{
START_THREAD (video_recorder, (void *)&video_recorder_param);
LOGD(TAG, "Video recorder thread start [OK]");
}
res = ardrone_tool_init(&ardrone_info.drone_address[0], strlen(&ardrone_info.drone_address[0]), NULL, param->app_name, param->user_name, param->root_dir, param->flight_dir, param->flight_storing_size, param->academy_download_callback_func);
if(SUCCEED(res))
{
ardrone_tool_input_add(&virtual_gamepad);
if (param != NULL && param->callback != NULL) {
param->callback(env, param->obj, ARDRONE_MESSAGE_CONNECTED_OK);
}
} else {
if (param != NULL && param->callback != NULL) {
param->callback(env, param->obj, ARDRONE_MESSAGE_UNKNOWN_ERR);
}
bContinue = FALSE;
}
res = ardrone_tool_set_refresh_time(1000 / kAPS);
#if USE_THREAD_PRIORITIES
CHANGE_THREAD_PRIO (app_main, AT_THREAD_PRIORITY);
CHANGE_THREAD_PRIO (navdata_update, NAVDATA_THREAD_PRIORITY);
CHANGE_THREAD_PRIO (ardrone_control, NAVDATA_THREAD_PRIORITY);
#endif
while( SUCCEED(res) && bContinue == TRUE )
{
ardrone_tool_update();
}
JOIN_THREAD(video_stage);
if (IS_LEAST_ARDRONE2)
{
JOIN_THREAD (video_recorder);
}
/* Unregistering for the current device */
ardrone_tool_input_remove( &virtual_gamepad );
res = ardrone_tool_shutdown();
LOGD(TAG, "AR.Drone tool shutdown [OK]");
if (param != NULL && param->callback != NULL) {
param->callback(env, param->obj, ARDRONE_MESSAGE_DISCONNECTED);
}
}
vp_os_free (data);
data = NULL;
(*env)->DeleteGlobalRef(env, param->obj);
if (g_vm) {
(*g_vm)->DetachCurrentThread (g_vm);
}
LOGI(TAG, "app_main thread has been stopped.");
return (THREAD_RET) res;
}
int ardrone_tool_main(int argc, char **argv)
{
C_RESULT res;
const char* old_locale;
const char* appname = argv[0];
int argc_backup = argc;
char** argv_backup = argv;
char * drone_ip_address = NULL;
struct in_addr drone_ip_address_in;
bool_t show_usage = FAILED( ardrone_tool_check_argc_custom(argc) ) ? TRUE : FALSE;
argc--; argv++;
while( argc && *argv[0] == '-' )
{
if( !strcmp(*argv, "-ip") && ( argc > 1 ) )
{
drone_ip_address = *(argv+1);
printf("Using custom ip address %s\n",drone_ip_address);
argc--; argv++;
}
else if( !strcmp(*argv, "-?") || !strcmp(*argv, "-h") || !strcmp(*argv, "-help") || !strcmp(*argv, "--help") )
{
ardrone_tool_usage( appname );
exit( 0 );
}
else if( !ardrone_tool_parse_cmd_line_custom( *argv ) )
{
printf("Option %s not recognized\n", *argv);
show_usage = TRUE;
}
argc--; argv++;
}
/*if( show_usage || (argc != 0) )
{
ardrone_tool_usage( appname );
exit(-1);
}*/
/* After a first analysis, the arguments are restored so they can be passed to the user-defined functions */
argc=argc_backup;
argv=argv_backup;
old_locale = setlocale(LC_NUMERIC, "en_GB.UTF-8");
if( old_locale == NULL )
{
PRINT("You have to install new locales in your dev environment! (avoid the need of conv_coma_to_dot)\n");
PRINT("As root, do a \"dpkg-reconfigure locales\" and add en_GB.UTF8 to your locale settings\n");
}
else
{
PRINT("Setting locale to %s\n", old_locale);
}
vp_com_wifi_config_t *config = (vp_com_wifi_config_t*)wifi_config();
if(config)
{
vp_os_memset( &wifi_ardrone_ip[0], 0, sizeof(wifi_ardrone_ip) );
if(drone_ip_address && inet_aton(drone_ip_address,&drone_ip_address_in)!=0)
{
/* If the drone IP address was given on the command line and is valid */
printf("===================+> %s\n", drone_ip_address);
strncpy( &wifi_ardrone_ip[0], drone_ip_address, sizeof(wifi_ardrone_ip)-1);
}
else
{
printf("===================+> %s\n", config->server);
strncpy( &wifi_ardrone_ip[0], config->server, sizeof(wifi_ardrone_ip)-1);
}
}
while (-1 == getDroneVersion (root_dir, wifi_ardrone_ip, &ardroneVersion))
{
printf ("Getting AR.Drone version ...\n");
vp_os_delay (250);
}
res = ardrone_tool_setup_com( NULL );
if( FAILED(res) )
{
PRINT("Wifi initialization failed. It means either:\n");
PRINT("\t* you're not root (it's mandatory because you can set up wifi connection only as root)\n");
PRINT("\t* wifi device is not present (on your pc or on your card)\n");
PRINT("\t* you set the wrong name for wifi interface (for example rausb0 instead of wlan0) \n");
PRINT("\t* ap is not up (reboot card or remove wifi usb dongle)\n");
PRINT("\t* wifi device has no antenna\n");
}
else
{
// Save appname/appid for reconnections
char *appname = NULL;
int lastSlashPos;
/* Cut the invoking name to the last / or \ character on the command line
* This avoids using differents app_id for applications called from different directories
* e.g. if argv[0] is "Build/Release/ardrone_navigation", appname will point to "ardrone_navigation" only
*/
for (lastSlashPos = strlen (argv[0])-1; lastSlashPos > 0 && argv[0][lastSlashPos] != '/' && argv[0][lastSlashPos] != '\\'; lastSlashPos--);
appname = &argv[0][lastSlashPos+1];
ardrone_gen_appid (appname, __SDK_VERSION__, app_id, app_name, sizeof (app_name));
res = ardrone_tool_init(wifi_ardrone_ip, strlen(wifi_ardrone_ip), NULL, appname, NULL, NULL, NULL, MAX_FLIGHT_STORING_SIZE, NULL);
while( SUCCEED(res) && ardrone_tool_exit() == FALSE )
{
res = ardrone_tool_update();
}
res = ardrone_tool_shutdown();
}
if( old_locale != NULL )
{
setlocale(LC_NUMERIC, old_locale);
}
return SUCCEED(res) ? 0 : -1;
}
DEFINE_THREAD_ROUTINE(video_stage, data) {
C_RESULT res;
vp_api_io_pipeline_t pipeline;
vp_api_io_data_t out;
vp_api_io_stage_t * stages;
video_stage_merge_slices_config_t merge_slices_cfg;
uint8_t i;
specific_parameters_t * params = (specific_parameters_t *)(data);
if (1 == params->needSetPriority)
{
CHANGE_THREAD_PRIO (video_stage, params->priority);
}
vp_os_memset(&icc_tcp, 0, sizeof ( icc_tcp));
vp_os_memset(&icc_udp, 0, sizeof ( icc_udp));
// Video Communication config
icc_tcp.com = COM_VIDEO();
icc_tcp.buffer_size = (1024*1024);
icc_tcp.protocol = VP_COM_TCP;
COM_CONFIG_SOCKET_VIDEO(&icc_tcp.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip);
// Video Communication config
icc_udp.com = COM_VIDEO();
icc_udp.buffer_size = (1024*1024);
icc_udp.protocol = VP_COM_UDP;
COM_CONFIG_SOCKET_VIDEO(&icc_udp.socket, VP_COM_CLIENT, 0, wifi_ardrone_ip);
icc_udp.socket.remotePort = VIDEO_PORT;
icc.nb_sockets = 2;
icc.configs = icc_tab;
icc.forceNonBlocking = &(tcpConf.tcpStageHasMoreData);
icc_tab[1] = &icc_tcp;
icc_tab[0] = &icc_udp;
icc.buffer_size = (1024*1024);
vp_os_memset(&vec, 0, sizeof ( vec));
stages = (vp_api_io_stage_t*) (vp_os_calloc(
NB_STAGES + params->pre_processing_stages_list->length + params->post_processing_stages_list->length,
sizeof (vp_api_io_stage_t)
));
vec.src_picture = params->in_pic;
vec.dst_picture = params->out_pic;
vp_os_memset(&tcpConf, 0, sizeof ( tcpConf));
tcpConf.maxPFramesPerIFrame = 30;
tcpConf.frameMeanSize = 160*1024;
tcpConf.tcpStageHasMoreData = FALSE;
tcpConf.latencyDrop = 1;
pipeline.nb_stages = 0;
pipeline.stages = &stages[0];
//ENCODED FRAME PROCESSING STAGES
stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET;
stages[pipeline.nb_stages].cfg = (void *) &icc;
stages[pipeline.nb_stages++].funcs = video_com_multisocket_funcs;
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void *) &tcpConf;
stages[pipeline.nb_stages++].funcs = video_stage_tcp_funcs;
// Record Encoded video
if(1 == ARDRONE_VERSION())
{
ardrone_academy_stage_recorder_config.dest.pipeline = video_pipeline_handle;
ardrone_academy_stage_recorder_config.dest.stage = pipeline.nb_stages;
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void*)&ardrone_academy_stage_recorder_config;
stages[pipeline.nb_stages++].funcs = ardrone_academy_stage_recorder_funcs;
}
else
{
// Nothing to do for AR.Drone 2 as we have a separated thread for recording
}
//PRE-DECODING STAGES ==> recording, ...
for(i=0;i<params->pre_processing_stages_list->length;i++){
stages[pipeline.nb_stages].type = params->pre_processing_stages_list->stages_list[i].type;
stages[pipeline.nb_stages].cfg = params->pre_processing_stages_list->stages_list[i].cfg;
stages[pipeline.nb_stages++].funcs = params->pre_processing_stages_list->stages_list[i].funcs;
}
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void *)&merge_slices_cfg;
stages[pipeline.nb_stages++].funcs = video_stage_merge_slices_funcs;
//DECODING STAGES
stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER;
stages[pipeline.nb_stages].cfg = (void*) &vec;
stages[pipeline.nb_stages++].funcs = video_decoding_funcs;
//POST-DECODING STAGES ==> transformation, display, ...
for(i=0;i<params->post_processing_stages_list->length;i++){
stages[pipeline.nb_stages].type = params->post_processing_stages_list->stages_list[i].type;
stages[pipeline.nb_stages].cfg = params->post_processing_stages_list->stages_list[i].cfg;
stages[pipeline.nb_stages++].funcs = params->post_processing_stages_list->stages_list[i].funcs;
}
if (!ardrone_tool_exit()) {
PRINT("\nvideo stage thread initialisation\n\n");
res = vp_api_open(&pipeline, &video_pipeline_handle);
if (SUCCEED(res)) {
int loop = SUCCESS;
out.status = VP_API_STATUS_PROCESSING;
while (!ardrone_tool_exit() && (loop == SUCCESS)) {
if (video_stage_in_pause) {
vp_os_mutex_lock(&video_stage_mutex);
icc.num_retries = VIDEO_MAX_RETRIES;
vp_os_cond_wait(&video_stage_condition);
vp_os_mutex_unlock(&video_stage_mutex);
}
if (SUCCEED(vp_api_run(&pipeline, &out))) {
if ((out.status == VP_API_STATUS_PROCESSING || out.status == VP_API_STATUS_STILL_RUNNING)) {
loop = SUCCESS;
}
} else loop = -1; // Finish this thread
}
vp_os_free(params->pre_processing_stages_list->stages_list);
params->pre_processing_stages_list->stages_list = NULL;
vp_os_free(params->post_processing_stages_list->stages_list);
params->post_processing_stages_list->stages_list = NULL;
vp_os_free(params->pre_processing_stages_list);
params->pre_processing_stages_list = NULL;
vp_os_free(params->post_processing_stages_list);
params->post_processing_stages_list = NULL;
vp_os_free(params->in_pic);
params->in_pic = NULL;
vp_os_free(params->out_pic);
params->out_pic = NULL;
vp_os_free(params);
params = NULL;
vp_api_close(&pipeline, &video_pipeline_handle);
}
}
PRINT("\nvideo stage thread ended\n\n");
return (THREAD_RET) 0;
}
void
nrm2CorrectnessTest(TestParams *params)
{
cl_int err;
T1 *blasX;
T2 *clblasNRM2, *blasNRM2;
cl_mem bufX, bufNRM2, scratchBuff;
clMath::BlasBase *base;
cl_event *events;
cl_double deltaForType = 0.0;
base = clMath::BlasBase::getInstance();
if ((typeid(T1) == typeid(cl_double) ||
typeid(T1) == typeid(DoubleComplex)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
printf("number of command queues : %d\n\n", params->numCommandQueues);
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
size_t lengthX = (1 + ((params->N -1) * abs(params->incx)));
blasX = new T1[lengthX + params->offBX ];
blasNRM2 = new T2[1];
clblasNRM2 = new T2[1 + params->offa];
if((blasX == NULL) || (clblasNRM2 == NULL) || (blasNRM2 == NULL))
{
::std::cerr << "Cannot allocate memory on host side\n" << "!!!!!!!!!!!!Test skipped.!!!!!!!!!!!!" << ::std::endl;
deleteBuffers<T1>(blasX);
deleteBuffers<T2>(blasNRM2, clblasNRM2);
delete[] events;
SUCCEED();
return;
}
srand(params->seed);
::std::cerr << "Generating input data... ";
randomVectors<T1>(params->N, (blasX + params->offBX), params->incx, (T1*)NULL, 0, true);
::std::cerr << "Done" << ::std::endl;
// Allocate buffers
bufX = base->createEnqueueBuffer(blasX, (lengthX + params->offBX)* sizeof(*blasX), 0, CL_MEM_READ_WRITE);
bufNRM2 = base->createEnqueueBuffer(NULL, (1 + params->offa) * sizeof(T2), 0, CL_MEM_READ_WRITE);
scratchBuff = base->createEnqueueBuffer(NULL, (lengthX * 2 * sizeof(T1)), 0, CL_MEM_READ_WRITE);
::std::cerr << "Calling reference xNRM2 routine... ";
*blasNRM2 = ::clMath::blas::nrm2( params->N, blasX, params->offBX, params->incx);
::std::cerr << "Done" << ::std::endl;
if ((bufX == NULL) || (bufNRM2 == NULL) || (scratchBuff == NULL)) {
releaseMemObjects(bufX, bufNRM2, scratchBuff);
deleteBuffers<T1>(blasX);
deleteBuffers<T2>(blasNRM2, clblasNRM2);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
::std::cerr << "Calling clblas xNRM2 routine... ";
DataType type;
type = ( typeid(T1) == typeid(cl_float))? TYPE_FLOAT : ( typeid(T1) == typeid(cl_double))? TYPE_DOUBLE: ( typeid(T1) == typeid(cl_float2))? TYPE_COMPLEX_FLOAT:TYPE_COMPLEX_DOUBLE;
err = (cl_int)::clMath::clblas::nrm2( type, params->N, bufNRM2, params->offa, bufX,
params->offBX, params->incx, scratchBuff, params->numCommandQueues, base->commandQueues(),
0, NULL, events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufX, bufNRM2, scratchBuff);
deleteBuffers<T1>(blasX);
deleteBuffers<T2>(blasNRM2, clblasNRM2);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::NRM2() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues, base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufX, bufNRM2, scratchBuff);
deleteBuffers<T1>(blasX);
deleteBuffers<T2>(blasNRM2, clblasNRM2);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
::std::cerr << "Done" << ::std::endl;
err = clEnqueueReadBuffer(base->commandQueues()[0], bufNRM2, CL_TRUE, 0,
(1 + params->offa) * sizeof(*clblasNRM2), clblasNRM2, 0, NULL, NULL);
if (err != CL_SUCCESS) {
::std::cerr << "NRM2: Reading results failed...." << std::endl;
}
releaseMemObjects(bufX, bufNRM2, scratchBuff);
deltaForType = DELTA_0<T1>();
// Since every element of X encounters a division, delta would be sum of deltas for every element in X
cl_double delta = 0;
for(unsigned int i=0; i<(params->N); i++) {
delta += deltaForType * returnMax<T1>(blasX[params->offBX + i]);
}
compareValues<T2>( (blasNRM2), (clblasNRM2+params->offa), delta);
deleteBuffers<T1>(blasX);
deleteBuffers<T2>(blasNRM2, clblasNRM2);
delete[] events;
}
int AK8973B::get_delay() {
unsigned short delay;
SUCCEED(ioctl(fd, ECS_IOCTL_GET_DELAY, &delay) == 0);
return delay;
}
TEST(has_difference_type_test, normal)
{
NEK_HAS_MEMBER_TYPE(nek::has_difference_type);
SUCCEED();
}
void AK8973B::wait_stop()
{
/* When open, we enable BMA and wait for close event. */
int status;
SUCCEED(ioctl(fd, ECS_IOCTL_GET_CLOSE_STATUS, &status) == 0);
}
TEST(ReqPtr, Casts) {
// Test cast operations
{
EXPECT_FALSE(isa<DummyResource>(req::ptr<DummyResource>(nullptr)));
EXPECT_TRUE(isa_or_null<DummyResource>(req::ptr<DummyResource>(nullptr)));
auto dummy = req::make<DummyResource>();
req::ptr<ResourceData> res(dummy);
req::ptr<ResourceData> empty;
req::ptr<File> emptyFile;
EXPECT_TRUE(isa<DummyResource>(res));
EXPECT_TRUE(isa_or_null<DummyResource>(res));
EXPECT_FALSE(isa<File>(res));
EXPECT_FALSE(isa_or_null<File>(res));
// cast tests
// Bad types and null pointers should throw.
EXPECT_EQ(cast<DummyResource>(res), dummy);
EXPECT_EQ(cast<ResourceData>(res), dummy);
try {
cast<File>(res);
ADD_FAILURE();
} catch(...) {
SUCCEED();
}
try {
cast<DummyResource>(empty);
ADD_FAILURE();
} catch(...) {
SUCCEED();
}
// cast_or_null tests
// Bad types should throw, null pointers are ok.
EXPECT_EQ(cast_or_null<ResourceData>(empty), nullptr);
EXPECT_EQ(cast_or_null<ResourceData>(dummy), dummy);
try {
cast_or_null<File>(res);
ADD_FAILURE();
} catch(...) {
SUCCEED();
}
// dyn_cast tests
// Bad types are ok, null pointers should throw.
EXPECT_EQ(dyn_cast<DummyResource>(res), dummy);
EXPECT_EQ(dyn_cast<ResourceData>(res), dummy);
EXPECT_EQ(dyn_cast<File>(res), nullptr);
try {
dyn_cast<File>(emptyFile);
ADD_FAILURE();
} catch(...) {
SUCCEED();
}
// dyn_cast_or_null
// Bad types and null pointers are ok. Should never throw.
EXPECT_EQ(dyn_cast_or_null<DummyResource>(res), res);
EXPECT_EQ(dyn_cast_or_null<File>(res), nullptr);
EXPECT_EQ(dyn_cast_or_null<ResourceData>(empty), nullptr);
EXPECT_EQ(dyn_cast_or_null<ResourceData>(emptyFile), nullptr);
}
}
TEST(gm,compile_models) {
SUCCEED()
<< "Model compilation done through makefile dependencies." << std::endl
<< "Should have compiled: src/test/gm/model_specs/compiled/*.stan";
}
TEST(TestNoFixture, NoName)
{
std::cout << "TEST TestNoFixture" << std::endl;
SUCCEED();
}
void
syrCorrectnessTest(TestParams *params)
{
cl_int err;
T *blasA, *clblasA, *X;
// T *tempA;
cl_mem bufA, bufX;
clMath::BlasBase *base;
cl_event *events;
bool useAlpha;
T alpha;
base = clMath::BlasBase::getInstance();
if ((typeid(T) == typeid(cl_double)) &&
!base->isDevSupportDoublePrecision()) {
std::cerr << ">> WARNING: The target device doesn't support native "
"double precision floating point arithmetic" <<
std::endl << ">> Test skipped" << std::endl;
SUCCEED();
return;
}
printf("number of command queues : %d\n\n", params->numCommandQueues);
events = new cl_event[params->numCommandQueues];
memset(events, 0, params->numCommandQueues * sizeof(cl_event));
size_t lengthA = params->N * params->lda;
size_t lengthX = (1 + ((params->N -1) * abs(params->incx)));
blasA = new T[lengthA + params->offa ];
clblasA = new T[lengthA + params->offa ];
X = new T[lengthX + params->offBX ];
// tempA = new T[lengthA + params->offa ];
srand(params->seed);
::std::cerr << "Generating input data... ";
memset(blasA, -1, (lengthA + params->offa));
memset(clblasA, -1, (lengthA + params->offa));
memset(X, -1, (lengthX + params->offBX));
alpha = convertMultiplier<T>(params->alpha);
useAlpha = true;
#ifdef DEBUG_SYR
printf("ALPHA in CORR_SYR.CPP %f\n", alpha);
#endif
if((blasA == NULL) || (X == NULL) || (clblasA == NULL))
{
::std::cerr << "Cannot allocate memory on host side\n" << "!!!!!!!!!!!!Test skipped.!!!!!!!!!!!!" << ::std::endl;
deleteBuffers<T>(blasA, clblasA, X);
delete[] events;
SUCCEED();
return;
}
randomSyrMatrices<T>(params->order, params->uplo, params->N, useAlpha, &alpha,
(blasA + params->offa), params->lda, (X + params->offBX), params->incx);
/*
// Set data in A and X using populate() routine
int creationFlags = 0;
creationFlags = creationFlags | RANDOM_INIT;
// Default is Column-Major
creationFlags = ( (params-> order) == clblasRowMajor)? (creationFlags | ROW_MAJOR_ORDER) : (creationFlags);
creationFlags = ( (params-> uplo) == clblasLower)? (creationFlags | LOWER_HALF_ONLY) : (creationFlags | UPPER_HALF_ONLY);
BlasRoutineID BlasFn = CLBLAS_SYR;
// Populate A and blasX
populate( blasA + params->offa, params-> N, params-> N, params-> lda, BlasFn, creationFlags);
populate( X , (lengthX + params->offBX), 1, (lengthX + params->offBX), BlasFn);
*/
// Copy blasA to clblasA
memcpy(clblasA, blasA, (lengthA + params->offa)* sizeof(*blasA));
// memcpy(tempA, blasA, (lengthA + params->offa)* sizeof(*blasA));
::std::cerr << "Done" << ::std::endl;
// Allocate buffers
bufA = base->createEnqueueBuffer(clblasA, (lengthA + params->offa) * sizeof(*clblasA), 0, CL_MEM_READ_WRITE);
bufX = base->createEnqueueBuffer(X, (lengthX + params->offBX)* sizeof(*X), 0, CL_MEM_READ_ONLY);
::std::cerr << "Calling reference xSYR routine... ";
clblasOrder order;
clblasUplo fUplo;
order = params->order;
fUplo = params->uplo;
//printf("\n\n before acml call\nA\n");
// printMatrixBlock( params->order, 0, 0, params->N, params->N, params->lda, blasA);
//printf("\nX\n");
//printMatrixBlock( clblasColumnMajor, 0, 0, lengthX, 1, lengthX, X);
if (order == clblasColumnMajor)
{
::clMath::blas::syr( clblasColumnMajor, fUplo, params->N, alpha, X, params->offBX, params->incx, blasA, params->offa, params->lda);
}
else
{
T *reorderedA = new T[lengthA + params->offa];
//reorderMatrix<T>(clblasRowMajor, params->N, params->lda, blasA, reorderedA);
fUplo = (fUplo == clblasUpper) ? clblasLower : clblasUpper;
//::clMath::blas::syr( clblasColumnMajor, fUplo, params->N, alpha, X, params->offBX, params->incx, reorderedA, params->offa, params->lda);
::clMath::blas::syr( clblasColumnMajor, fUplo, params->N, alpha, X, params->offBX, params->incx, blasA, params->offa, params->lda);
//reorderMatrix<T>(clblasColumnMajor, params->lda, params->N, reorderedA, blasA);
delete[] reorderedA;
}
//printf("After acml\n");
//printMatrixBlock( params->order, 0, 0, params->N, params->N, params->lda, blasA);
::std::cerr << "Done" << ::std::endl;
if ((bufA == NULL) || (bufX == NULL) ) {
/* Skip the test, the most probable reason is
* matrix too big for a device.
*/
releaseMemObjects(bufA, bufX);
deleteBuffers<T>(blasA, clblasA, X);
delete[] events;
::std::cerr << ">> Failed to create/enqueue buffer for a matrix."
<< ::std::endl
<< ">> Can't execute the test, because data is not transfered to GPU."
<< ::std::endl
<< ">> Test skipped." << ::std::endl;
SUCCEED();
return;
}
::std::cerr << "Calling clblas xSYR routine... ";
err = (cl_int)::clMath::clblas::syr( params->order, params->uplo, params->N, alpha,
bufX, params->offBX, params->incx, bufA, params->offa, params->lda,
params->numCommandQueues, base->commandQueues(),
0, NULL, events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufX);
deleteBuffers<T>(blasA, clblasA, X);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "::clMath::clblas::SYR() failed";
}
err = waitForSuccessfulFinish(params->numCommandQueues,
base->commandQueues(), events);
if (err != CL_SUCCESS) {
releaseMemObjects(bufA, bufX);
deleteBuffers<T>(blasA, clblasA, X);
delete[] events;
ASSERT_EQ(CL_SUCCESS, err) << "waitForSuccessfulFinish()";
}
::std::cerr << "Done" << ::std::endl;
err = clEnqueueReadBuffer(base->commandQueues()[0], bufA, CL_TRUE, 0,
(lengthA + params->offa) * sizeof(*clblasA), clblasA, 0,
NULL, NULL);
if (err != CL_SUCCESS)
{
::std::cerr << "SYR: Reading results failed...." << std::endl;
}
releaseMemObjects(bufA, bufX);
//printMatrixBlock( params->order, 0, 0, params->N, params->N, params->lda, clblasA);
//getchar();
// printf("Comparing with the temp buffer\n");
// compareMatrices<T>(clblasColumnMajor, 1, (params->lda - params->N), (blasA + params->offa + params->N), (tempA + params->offa + params->N),
// params->lda);
// delete[] tempA;
printf("Comparing the results\n");
compareMatrices<T>(params->order, params->N , params->N, (blasA + params->offa), (clblasA + params->offa),
params->lda);
deleteBuffers<T>(blasA, clblasA, X);
delete[] events;
}
TEST_F(TestFixture1, NoName)
{
std::cout << "TEST TestFixture1 NoName" << std::endl;
SUCCEED();
}
TEST_CASE()
{
SUCCEED( "anonymous test case" );
}
TEST(FailureTest, NormalTest) {
ADD_FAILURE() << "sorry dushishuang!";
SUCCEED();
}