check data transfer from host to device More...

#include <tf_checktransferin.h>

Inheritance diagram for TF_CheckTransferIn:

Public Member Functions
void	CheckBuffer (cl_uint *ptr)
	check data in the buffer More...

virtual void	CleanupInThread ()
	Free any resource. More...

virtual void	GetResultInThread ()
	Show results of test. More...

void	GetStatus (void)
	Read status information from device. More...

virtual void	PrepareInThread ()
	Prepare test. More...

virtual void	Run ()
	Main body of test. More...

void	SetBuffer (cl_uint *ptr)
	set test data in buffer buffer More...

void	StartCalculateBuf (cl::Buffer *pDevice, cl::Event &event)
	Start kernel for buffer. More...

void	StartReadBuf (cl::Buffer pDevice, cl_uint pHost, cl::Event &event)
	Start data transfer. More...

virtual void	StepTable ()
	Show table during test executing. More...

	TF_CheckTransferIn (TableEngine pTable, TF_Device pDevice, int argc, char **argv)
	Constructor. More...

void	WaitForCalculateComplete (cl::Event &event)
	Wait for complete calculate. More...

void	WaitForTransferBufComplete (cl::Event &event)
	Wait for complete data transfer. More...

	~TF_CheckTransferIn ()
	Destructor. More...

Public Member Functions inherited from TF_TestThread
void *	Execute ()

virtual void	GetResult ()
	Show result of test. More...

virtual int	isComplete ()
	Return 1 when test is complete. More...

virtual int	Prepare (int cnt)
	Prepare test. More...

virtual void	Start ()
	Start of test. More...

virtual void	Stop ()
	Stop of test. More...

	TF_TestThread (TableEngine pTable, int argc, char *argv)

virtual	~TF_TestThread ()

Public Member Functions inherited from TF_Test
virtual void	StepMainThread ()
	Don't use. Reserve for future. More...

	TF_Test (TableEngine *pTable)

Public Attributes
TF_CheckTransferIn_task_data *	td
	< Internal data for TF_CheckTransferIn More...

Public Attributes inherited from TF_TestThread
pthread_attr_t	m_attrThread

int	m_CycleCnt

pthread_t	m_hThread

int	m_isComplete

int	m_isException

int	m_isPrepareComplete

int	m_isTerminate

pthread_mutex_t	m_ResultCompleteMutex

pthread_mutex_t	m_ResultStartMutex

pthread_mutex_t	m_StartMutex

pthread_mutex_t	m_ThreadExitMutex

Public Attributes inherited from TF_Test
TableEngine *	m_pTemplateEngine

Additional Inherited Members
Static Public Member Functions inherited from TF_TestThread
static void *	ThreadFunc (void *lpvThreadParm)

Detailed Description

check data transfer from host to device

Definition at line 19 of file tf_checktransferin.h.

Constructor & Destructor Documentation

◆ TF_CheckTransferIn()

TF_CheckTransferIn::TF_CheckTransferIn	(	TableEngine *	pTable,
		TF_Device *	pDevice,
		int	argc,
		char **	argv
	)

Constructor.

Parameters

argc	Number of arguments argv Pointer of argumnts

arguments of command line:

    -size   <n>             : size block of kilobytes, default 64
    -metric <n>             : 0 - binary:  1MB=2^10=1024*1024=1048576 bytes,
                                      1 - decimal: 1MB=10^6=1000*1000=1000000 bytes,
                                      default 0

Definition at line 133 of file tf_checktransferin.cpp.

References GetFromCommnadLine(), TF_CheckTransferIn_task_data::mbSize, TF_CheckTransferIn_task_data::metricMode, TF_CheckTransferIn_task_data::pDevice, TF_CheckTransferIn_task_data::sizeBlock, and td.

                                                                                                          : TF_TestThread( pTable, argc, argv )
 {
     td = new TF_CheckTransferIn_task_data();
 
     td->sizeBlock = 1024 * GetFromCommnadLine( argc, argv, "-size", 64 );
 
     td->metricMode = GetFromCommnadLine( argc, argv, "-metric", 0 );
     if( 0==td->metricMode )
         td->mbSize = 1024*1024;
     else
         td->mbSize = 1000000;
 
     td->pDevice = pDevice;
 
 }

◆ ~TF_CheckTransferIn()

TF_CheckTransferIn::~TF_CheckTransferIn ( )

Destructor.

Definition at line 150 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::dpStatus, TF_CheckTransferIn_task_data::pBuffer, TF_CheckTransferIn_task_data::pBufOut, TF_CheckTransferIn_task_data::pStatus, and td.

 {
 
     free( td->pBufOut[0] ); td->pBufOut[0]=NULL;
     free( td->pBufOut[1] ); td->pBufOut[1]=NULL;
     free( td->pStatus );        td->pStatus=NULL;
 
 
     delete td->pBuffer[0]; td->pBuffer[0]=NULL;
     delete td->pBuffer[1]; td->pBuffer[1]=NULL;
     delete td->dpStatus;  td->dpStatus=NULL;
 
 
     delete td; td=NULL;
 }

Member Function Documentation

◆ CheckBuffer()

void TF_CheckTransferIn::CheckBuffer ( cl_uint * ptr )

check data in the buffer

Definition at line 597 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::BlockError, TF_CheckTransferIn_task_data::BlockOk, TF_CheckTransferIn_task_data::dataExpect, TF_CheckTransferIn_task_data::sizeBlock, and td.

Referenced by Run().

 {
         cl_ulong *src = (cl_ulong*)ptr;
     cl_uint count = td->sizeBlock / sizeof(cl_ulong);
     cl_ulong val=td->dataExpect;
     cl_ulong di;
     cl_ulong flag_error=0;
     for( int ii=0; ii<count; ii++ )
     {
         di = *src++;
 
         if( di!=val )
         {
             flag_error++;
         }
         val++;
     }
     td->dataExpect=val;
 
     if( 0==flag_error )
         td->BlockOk++;
     else
         td->BlockError++;
 }

◆ CleanupInThread()

void TF_CheckTransferIn::CleanupInThread ( )

virtual

Free any resource.

Implements TF_TestThread.

Definition at line 323 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::q0, TF_CheckTransferIn_task_data::q1, and td.

 {
     printf( "TF_CheckTransferIn::%s\n\n", __FUNCTION__ );
 
     delete td->q0;  td->q0=NULL;
     delete td->q1;      td->q1=NULL;
 
 
 }

◆ GetResultInThread()

void TF_CheckTransferIn::GetResultInThread ( )

virtual

Show results of test.

Implements TF_TestThread.

Definition at line 334 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::BlockError, TF_CheckTransferIn_task_data::BlockOk, TF_CheckTransferIn_task_data::BlockRd, TF_CheckTransferIn_task_data::BlockWr, TF_CheckTransferIn_task_data::metricMode, TF_CheckTransferIn_task_data::Sig, TF_CheckTransferIn_task_data::sizeBlock, td, TF_CheckTransferIn_task_data::testTime, TF_CheckTransferIn_task_data::VelocityAverage, TF_CheckTransferIn_task_data::VelocityCurMax, and TF_CheckTransferIn_task_data::VelocityCurMin.

 {
     printf( "\nTF_CheckTransferIn::%s\n\n", __FUNCTION__ );
     //GetStatus();
 
     int flag_error=0;
 
     if( 0xAA56==td->Sig )
     {
         printf( "Sig=0xAA56 - Ok\n");
     } else
     {
         printf( "Sig=0x%X - Error, expect 0xAA56\n", td->Sig );
         flag_error=1;
     }
     printf( "BlockWr    = %d\n", td->BlockWr );
     printf( "BlockRd    = %d\n", td->BlockRd );
     printf( "BlockOK    = %d\n", td->BlockOk );
     printf( "BlockError = %d\n\n", td->BlockError );
 
     printf( "Size of block  = %u \n\n", td->sizeBlock);
 
     printf( "Test time  = %-.0f s\n\n", td->testTime);
 
     printf( "VelocityAverage    = %10.1f MB/s\n", td->VelocityAverage );
     printf( "VelocityCurrentMax = %10.1f MB/s\n", td->VelocityCurMax );
     printf( "VelocityCurrentMin = %10.1f MB/s\n\n", td->VelocityCurMin );
 
     if( 0==td->metricMode)
         printf( " 1 MB = 2^10 = 1024*1024 = 1048576 bytes\n");
     else
         printf( " 1 MB = 10^6 = 1000000 bytes\n");
 
 
 
     if( 0 == td->BlockRd )
         flag_error++;
 
     if( 0 != td->BlockError )
         flag_error++;
 
     if( 0==flag_error )
         printf( "\nTest finished successfully\n\n" );
     else
         printf( "\nTest finished with errors\n\n" );
 
 }

◆ GetStatus()

void TF_CheckTransferIn::GetStatus ( void )

Read status information from device.

Definition at line 623 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::BlockWr, TF_CheckTransferIn_task_data::dpStatus, TF_CheckTransferIn_task_data::pStatus, TF_CheckTransferIn_task_data::q0, TF_CheckTransferIn_task_data::Sig, and td.

Referenced by Run().

 {
         if( NULL==td->pStatus )
                 return;
 
 
     cl_int ret=td->q0->enqueueReadBuffer(
             *(td->dpStatus),
             CL_TRUE,
             0,
             512,
             td->pStatus,
             NULL,
             NULL
             );
 
         td->Sig            = td->pStatus[0];
         td->BlockWr    = td->pStatus[1];
 
 }

◆ PrepareInThread()

void TF_CheckTransferIn::PrepareInThread ( )

virtual

Prepare test.

This function executed before main body of test.

Implements TF_TestThread.

Definition at line 172 of file tf_checktransferin.cpp.

 {
     printf( "\n");
     printf( "TF_CheckTransferIn::%s\n\n", __FUNCTION__ );
 
 
     cl::Kernel krnl_calculate( td->pDevice->program, "gen_cnt" );
     td->krnl_calculate = krnl_calculate;
 
 
     td->sizeOfuint16 = td->sizeBlock/64;  // count of words by 512 bits
 
 
     printf( "Alloc host memory 2 x %d ", td->sizeBlock );
     {
         void *ptr=(void*)0xAAAA;
         int err;
         err = posix_memalign( &ptr, 4096, td->sizeBlock );
         if( err )
             throw except_info( "%s - memory allocation error ", __FUNCTION__);
         td->pBufOut[0] = (cl_uint*) ptr;
         //printf( "ptr=%p\n", ptr );
 
         err = posix_memalign( &ptr, 4096, td->sizeBlock );
         if( err )
                 throw except_info( "%s - memory allocation error ", __FUNCTION__);
         td->pBufOut[1] = (cl_uint*) ptr;
 
         //printf( "ptr=%p\n", ptr );
 
 
 
         err = posix_memalign( &ptr, 4096, 16384 );
         if( err )
                 throw except_info( "%s - memory allocation error ", __FUNCTION__);
         td->pStatus = (cl_uint*) ptr;
 
 
     }
     printf( " - Ok\n" );
 
     printf( "Alloc device memory 2 x %d (DDR0 & DDR1) ", td->sizeBlock );
     {
         cl::Buffer *pBuf;
 
         cl_mem_ext_ptr_t input_buffer_ext;
 
         input_buffer_ext.flags = XCL_MEM_DDR_BANK0;
         input_buffer_ext.obj = NULL;
         input_buffer_ext.param = 0;
 
         pBuf = new cl::Buffer( td->pDevice->context,
                                CL_MEM_READ_WRITE | CL_MEM_EXT_PTR_XILINX,
                                td->sizeBlock,
                                &input_buffer_ext
                                );
         td->pBuffer[0] = pBuf;
     }
 
     {
         cl::Buffer *pBuf;
 
         cl_mem_ext_ptr_t input_buffer_ext;
 
         input_buffer_ext.flags = XCL_MEM_DDR_BANK0;
         input_buffer_ext.obj = NULL;
         input_buffer_ext.param = 0;
 
         pBuf = new cl::Buffer( td->pDevice->context,
                                CL_MEM_READ_WRITE | CL_MEM_EXT_PTR_XILINX,
                                td->sizeBlock,
                                &input_buffer_ext
                                );
         td->pBuffer[1] = pBuf;
     }
 
     {
         cl::Buffer *pBuf;
 
         cl_mem_ext_ptr_t input_buffer_ext;
 
         input_buffer_ext.flags = XCL_MEM_DDR_BANK0;
         input_buffer_ext.obj = NULL;
         input_buffer_ext.param = 0;
 
         pBuf = new cl::Buffer( td->pDevice->context,
                                CL_MEM_READ_WRITE | CL_MEM_EXT_PTR_XILINX,
                                16384,
                                &input_buffer_ext
                                );
         td->dpStatus = pBuf;
 
 
     }
 
 
     {
         cl_int err0;
         cl_int err1;
 
         cl_command_queue_properties properties0 = CL_QUEUE_PROFILING_ENABLE;
         cl_command_queue_properties properties1 = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
 
         td->q0 = new cl::CommandQueue(td->pDevice->context, td->pDevice->device, properties0, &err0 );
         td->q1 = new cl::CommandQueue(td->pDevice->context, td->pDevice->device, properties1, &err1 );
 
         if( CL_SUCCESS != err0 )
                 throw except_info( "%s - Error for create CommandQueue q0; err=%d ", __FUNCTION__, err0 );
 
         if( CL_SUCCESS != err1 )
                 throw except_info( "%s - Error for create CommandQueue q1; err=%d ", __FUNCTION__, err1 );
 
     }
     {
         for( int ii=0; ii<512; ii++ )
         {
                 td->pStatus[ii]=0;
         }
         td->pStatus[0]=0xBB67;
 
         cl_ulong val=td->dataOut;
         cl_ulong *ptr = (cl_ulong *)&(td->pStatus[16]);
 
         // Set initial value
         for( int ii=0; ii<8; ii++ )
         {
                 *ptr++ = val++;
         }
 
         // Set add const
         for( int ii=0; ii<8; ii++ )
         {
                 *ptr++=8;
         }
 
                 cl_int ret=td->q0->enqueueWriteBuffer(
                                 *(td->dpStatus),
                                 CL_TRUE,
                                 0,
                                 4096,
                                 td->pStatus,
                                 NULL,
                                 NULL
                                 );
     }
 
     printf( " - Ok\n" );
 
 }

◆ Run()

void TF_CheckTransferIn::Run ( )

virtual

Main body of test.

Implements TF_TestThread.

Definition at line 454 of file tf_checktransferin.cpp.

 {
     td->RowNumber=m_pTemplateEngine->AddRowTable();
 
 
     cl::Event eventCompletionTransfer0;
     cl::Event eventCompletionTransfer1;
     cl::Event eventCompletionExecuting0;
     cl::Event eventCompletionExecuting1;
     cl_int ret;
 
     std::vector<cl::Event>  events0;
     std::vector<cl::Event>  events1;
 
     int flag_continue=0;
     int flag_first_velocity=1;
 
 
 
     td->lastTime = td->startTime = time(NULL);
 
     // start check buffer 0 on device - quick time
     StartCalculateBuf( td->pBuffer[0], eventCompletionExecuting0 );
 
 
     for( ; ; )
     {
         if( this->m_isTerminate )
             break;
 
 
         if( td->flagGetStatus )
         {
                 GetStatus();
                 td->flagGetStatus=0;
         }
 
         // Main body
 
         WaitForCalculateComplete( eventCompletionExecuting0 );
 
         // start data transfer from buffer 0 on device - quick time
         StartReadBuf( td->pBuffer[0], td->pBufOut[0], eventCompletionTransfer0 );
 
         // start check buffer 1 on device - quick time
         StartCalculateBuf( td->pBuffer[1], eventCompletionExecuting1 );
 
         if( flag_continue )
         {
             // check buffer 0 - long time operation
             CheckBuffer( td->pBufOut[1] );
         }
 
         // wait complete transfer 0 - first wait
         WaitForTransferBufComplete( eventCompletionTransfer0 );
 
         WaitForCalculateComplete( eventCompletionExecuting1 );
 
         // start data transfer from buffer 1 on device - quick time
         StartReadBuf( td->pBuffer[1], td->pBufOut[1], eventCompletionTransfer1 );
 
         // start check buffer 0 on device - quick time
         StartCalculateBuf( td->pBuffer[0], eventCompletionExecuting0 );
 
         // check buffer 0 - long time operation
         CheckBuffer( td->pBufOut[0] );
 
         // wait complete transfer 1 - first wait
         WaitForTransferBufComplete( eventCompletionTransfer1 );
 
 
         flag_continue=1;
 
 
         time_t currentTime = time(NULL);
         time_t timeFromStart = currentTime - td->startTime;
         time_t diff = currentTime - td->lastTime;
         td->testTime = timeFromStart;
 
         if( diff >= 4 )
         {
             double velocity = (1.0L*(td->BlockRd-td->lastBlock)*td->sizeBlock)/diff;
 
             td->VelocityCurrent = velocity / (td->mbSize);
 
 
             velocity = 1.0L*(td->BlockRd)*td->sizeBlock/timeFromStart;
 
             td->VelocityAverage = velocity / (td->mbSize);
 
             td->lastTime = currentTime;
             td->lastBlock = td->BlockRd;
 
             if( 1==flag_first_velocity )
             {
                 td->VelocityCurMax=td->VelocityCurrent;
                 td->VelocityCurMin=td->VelocityCurrent;
                 flag_first_velocity=0;
             } else
             {
                 if( td->VelocityCurrent>td->VelocityCurMax )
                         td->VelocityCurMax=td->VelocityCurrent;
 
                 if( td->VelocityCurrent<td->VelocityCurMin )
                         td->VelocityCurMin=td->VelocityCurrent;
 
             }
         }
     }
 
     GetStatus();
 
 }

◆ SetBuffer()

void TF_CheckTransferIn::SetBuffer ( cl_uint * ptr )

set test data in buffer buffer

set test data in buffer

Definition at line 569 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::dataOut, TF_CheckTransferIn_task_data::sizeBlock, and td.

 {
         cl_ulong *dst = (cl_ulong*) ptr;
     cl_uint count = td->sizeBlock / sizeof(cl_ulong) / 16;
     cl_ulong val=td->dataOut;
     for( cl_uint ii=0; ii<count; ii++ )
     {
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
         *dst++=val++;
     }
     td->dataOut=val;
 }

◆ StartCalculateBuf()

void TF_CheckTransferIn::StartCalculateBuf	(	cl::Buffer *	pDevice,
		cl::Event &	event
	)

Start kernel for buffer.

Definition at line 423 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::dpStatus, TF_CheckTransferIn_task_data::krnl_calculate, TF_CheckTransferIn_task_data::q1, TF_CheckTransferIn_task_data::sizeOfuint16, and td.

Referenced by Run().

 {
 
     cl::NDRange globalNDR(1,1,1);
     cl::NDRange localNDR(1,1,1);
     cl::NDRange offsetNDR=cl::NullRange;
 
         td->krnl_calculate.setArg( 0, *pBufDevice );
         td->krnl_calculate.setArg( 1, *(td->dpStatus) );
         td->krnl_calculate.setArg( 2, td->sizeOfuint16 );
 
         td->q1->enqueueNDRangeKernel(
                         td->krnl_calculate,
                         offsetNDR,
                         globalNDR,
                         localNDR,
                         NULL,   //&events0,
                         &event  //&eventCompletionExecuting0
 
                         );
 
 }

◆ StartReadBuf()

void TF_CheckTransferIn::StartReadBuf	(	cl::Buffer *	pDevice,
		cl_uint *	pHost,
		cl::Event &	event
	)

Start data transfer.

Definition at line 407 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::BlockRd, TF_CheckTransferIn_task_data::q0, TF_CheckTransferIn_task_data::sizeBlock, and td.

Referenced by Run().

 {
     td->q0->enqueueReadBuffer(
                         *(pBufDevice),
                         CL_FALSE,
                         0,
                         td->sizeBlock,
                         pHost,
                         NULL,
                         &event
                         );
 
     td->BlockRd++;
 }

◆ StepTable()

void TF_CheckTransferIn::StepTable ( )

virtual

Show table during test executing.

Implements TF_TestThread.

Definition at line 383 of file tf_checktransferin.cpp.

References TF_CheckTransferIn_task_data::BlockError, TF_CheckTransferIn_task_data::BlockOk, TF_CheckTransferIn_task_data::BlockRd, TF_CheckTransferIn_task_data::BlockWr, TF_CheckTransferIn_task_data::flagGetStatus, TF_Test::m_pTemplateEngine, TF_CheckTransferIn_task_data::RowNumber, TableEngine::SetValueTable(), td, TF_CheckTransferIn_task_data::testTime, TF_CheckTransferIn_task_data::VelocityAverage, and TF_CheckTransferIn_task_data::VelocityCurrent.

 {
     m_pTemplateEngine->SetValueTable( td->RowNumber, 1, (unsigned)td->BlockWr, "%10d" );
     m_pTemplateEngine->SetValueTable( td->RowNumber, 2, (unsigned)td->BlockRd, "%10d" );
 
     m_pTemplateEngine->SetValueTable( td->RowNumber, 3, (unsigned)td->BlockOk, "%10d" );
     m_pTemplateEngine->SetValueTable( td->RowNumber, 4, (unsigned)td->BlockError, "%10d" );
     m_pTemplateEngine->SetValueTable( td->RowNumber, 5, td->VelocityCurrent, "%10.1f" );
     m_pTemplateEngine->SetValueTable( td->RowNumber, 6, td->VelocityAverage, "%10.1f" );
 
     m_pTemplateEngine->SetValueTable( td->RowNumber, 0, "IN: %7.1f", td->testTime );
 
 
     td->flagGetStatus=1;
 }

◆ WaitForCalculateComplete()

void TF_CheckTransferIn::WaitForCalculateComplete ( cl::Event & event )

Wait for complete calculate.

Definition at line 447 of file tf_checktransferin.cpp.

Referenced by Run().

 {
         event.wait();
 }

◆ WaitForTransferBufComplete()

void TF_CheckTransferIn::WaitForTransferBufComplete ( cl::Event & event )

Wait for complete data transfer.

Definition at line 401 of file tf_checktransferin.cpp.

Referenced by Run().

 {
     event.wait();
 }

Member Data Documentation

◆ td

TF_CheckTransferIn_task_data* TF_CheckTransferIn::td

< Internal data for TF_CheckTransferIn

Definition at line 24 of file tf_checktransferin.h.

Referenced by CheckBuffer(), CleanupInThread(), GetResultInThread(), GetStatus(), PrepareInThread(), Run(), SetBuffer(), StartCalculateBuf(), StartReadBuf(), StepTable(), TF_CheckTransferIn(), and ~TF_CheckTransferIn().

The documentation for this class was generated from the following files:

host/tf_checktransferin.h
host/tf_checktransferin.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TF_CheckTransferIn()

◆ ~TF_CheckTransferIn()

Member Function Documentation

◆ CheckBuffer()

◆ CleanupInThread()

◆ GetResultInThread()

◆ GetStatus()

◆ PrepareInThread()

◆ Run()

◆ SetBuffer()

◆ StartCalculateBuf()

◆ StartReadBuf()

◆ StepTable()

◆ WaitForCalculateComplete()

◆ WaitForTransferBufComplete()

Member Data Documentation

◆ td