check data transfer from device to host More...

#include <tf_checktransferout.h>

Inheritance diagram for TF_CheckTransferOut:

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	StartWriteBuf (cl::Buffer pDevice, cl_uint pHost, cl::Event &event)
	Start data transfer. More...

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

	TF_CheckTransferOut (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_CheckTransferOut ()
	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_CheckTransferOut_task_data *	td
	< Internal data for TF_CheckTransferOut 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 device to host

Definition at line 19 of file tf_checktransferout.h.

Constructor & Destructor Documentation

◆ TF_CheckTransferOut()

TF_CheckTransferOut::TF_CheckTransferOut	(	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 132 of file tf_checktransferout.cpp.

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

                                                                                                            : TF_TestThread( pTable, argc, argv )
 {
     td = new TF_CheckTransferOut_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_CheckTransferOut()

TF_CheckTransferOut::~TF_CheckTransferOut ( )

Destructor.

Definition at line 149 of file tf_checktransferout.cpp.

References TF_CheckTransferOut_task_data::dpStatus, TF_CheckTransferOut_task_data::pBuffer, TF_CheckTransferOut_task_data::pBufOut, TF_CheckTransferOut_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_CheckTransferOut::CheckBuffer ( cl_uint * ptr )

check data in the buffer

Definition at line 619 of file tf_checktransferout.cpp.

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

 {
         cl_ulong *src = (cl_ulong*)ptr;
     cl_uint count = td->sizeBlock / sizeof(cl_uint);
     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_CheckTransferOut::CleanupInThread ( )

virtual

Free any resource.

Implements TF_TestThread.

Definition at line 324 of file tf_checktransferout.cpp.

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

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

◆ GetResultInThread()

void TF_CheckTransferOut::GetResultInThread ( )

virtual

Show results of test.

Implements TF_TestThread.

Definition at line 335 of file tf_checktransferout.cpp.

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

 {
     printf( "\nTF_CheckTransferOut::%s\n\n", __FUNCTION__ );
     //GetStatus();
 
     int flag_error=0;
 
     if( 0xAA55==td->Sig )
     {
         printf( "Sig=0xAA55 - Ok\n");
     } else
     {
         printf( "Sig=0x%X - Error, expect 0xAA55\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( td->BlockOk!=td->BlockRd )
         flag_error++;
 
     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_CheckTransferOut::GetStatus ( void )

Read status information from device.

Definition at line 645 of file tf_checktransferout.cpp.

References TF_CheckTransferOut_task_data::BlockError, TF_CheckTransferOut_task_data::BlockOk, TF_CheckTransferOut_task_data::BlockRd, TF_CheckTransferOut_task_data::dpStatus, TF_CheckTransferOut_task_data::pStatus, TF_CheckTransferOut_task_data::q0, TF_CheckTransferOut_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->BlockRd    = td->pStatus[1];
         td->BlockOk    = td->pStatus[2];
         td->BlockError = td->pStatus[3];
 
 }

◆ PrepareInThread()

void TF_CheckTransferOut::PrepareInThread ( )

virtual

Prepare test.

This function executed before main body of test.

Implements TF_TestThread.

Definition at line 171 of file tf_checktransferout.cpp.

 {
     printf( "\n");
     printf( "TF_CheckTransferOut::%s\n\n", __FUNCTION__ );
 
     cl::Kernel krnl_read( td->pDevice->program, "check_read_input" );
     td->krnl_read = krnl_read;
 
     cl::Kernel krnl_calculate( td->pDevice->program, "check_cnt_m2a" );
     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]=0xBB66;
 
         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_CheckTransferOut::Run ( )

virtual

Main body of test.

Implements TF_TestThread.

Definition at line 470 of file tf_checktransferout.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_wait=0;
     int flag_first_velocity=1;
 
 
     td->lastTime = td->startTime = time(NULL);
 
     // set buffer 0 on host - long time operation
     SetBuffer( td->pBufOut[0] );
 
     // start data transfer for buffer 0 on device - quick time
     StartWriteBuf( td->pBuffer[0], td->pBufOut[0], eventCompletionTransfer0 );
 
     // set buffer 1 on host - long time operation
     SetBuffer( td->pBufOut[1] );
 
     for( ; ; )
     {
         if( this->m_isTerminate )
             break;
 
 
         if( td->flagGetStatus )
         {
                 GetStatus();
                 td->flagGetStatus=0;
         }
 
         // Main body
 
         // wait complete transfer 0 - first wait
         WaitForTransferBufComplete( eventCompletionTransfer0 );
 
         if( flag_wait )
             // wait for buffer1 processing
             WaitForCalculateComplete( eventCompletionExecuting1 );
 
         // start data transfer for buffer 1 on device - quick time
         StartWriteBuf( td->pBuffer[1], td->pBufOut[1], eventCompletionTransfer1 );
 
 
         // start check buffer 0 on device - quick time
         StartCalculateBuf( td->pBuffer[0], eventCompletionExecuting0 );
 
         // set buffer 0 on host - long time operation
         SetBuffer( td->pBufOut[0] );
 
         // wait for complete transfer 0 - second wait
         WaitForTransferBufComplete( eventCompletionTransfer1 );
 
         // wait for buffer0 processing
         WaitForCalculateComplete( eventCompletionExecuting0 );
 
         // start data transfer for buffer 0 on device - quick time
         StartWriteBuf( td->pBuffer[0], td->pBufOut[0], eventCompletionTransfer0 );
 
 
         // start check buffer 1 on device - quick time
         StartCalculateBuf( td->pBuffer[1], eventCompletionExecuting1 );
 
         // set buffer 1 on host - long time operation
         SetBuffer( td->pBufOut[1] );
 
         flag_wait=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->BlockWr-td->lastBlock)*td->sizeBlock)/diff;
 
             td->VelocityCurrent = velocity / (td->mbSize);
 
 
             velocity = 1.0L*(td->BlockWr)*td->sizeBlock/timeFromStart;
 
             td->VelocityAverage = velocity / (td->mbSize);
 
             td->lastTime = currentTime;
             td->lastBlock = td->BlockWr;
 
             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_CheckTransferOut::SetBuffer ( cl_uint * ptr )

set test data in buffer buffer

set test data in buffer

Definition at line 591 of file tf_checktransferout.cpp.

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

Referenced by Run().

 {
         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_CheckTransferOut::StartCalculateBuf	(	cl::Buffer *	pDevice,
		cl::Event &	event
	)

Start kernel for buffer.

Definition at line 427 of file tf_checktransferout.cpp.

References TF_CheckTransferOut_task_data::dpStatus, TF_CheckTransferOut_task_data::krnl_calculate, TF_CheckTransferOut_task_data::krnl_read, TF_CheckTransferOut_task_data::q1, TF_CheckTransferOut_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, *(td->dpStatus) );
         td->krnl_calculate.setArg( 1, td->sizeOfuint16 );
 
         td->q1->enqueueNDRangeKernel(
                         td->krnl_calculate,
                         offsetNDR,
                         globalNDR,
                         localNDR,
                         NULL,   //&events0,
                         &event  //&eventCompletionExecuting0
 
                         );
 
         td->krnl_read.setArg( 0, *pBufDevice );
         td->krnl_read.setArg( 1, td->sizeOfuint16 );
 
         td->q1->enqueueNDRangeKernel(
                         td->krnl_read,
                         offsetNDR,
                         globalNDR,
                         localNDR,
                         NULL,           // &events0,
                         NULL            // &eventCompletionExecuting0
 
                         );
 }

◆ StartWriteBuf()

void TF_CheckTransferOut::StartWriteBuf	(	cl::Buffer *	pDevice,
		cl_uint *	pHost,
		cl::Event &	event
	)

Start data transfer.

Definition at line 411 of file tf_checktransferout.cpp.

References TF_CheckTransferOut_task_data::BlockWr, TF_CheckTransferOut_task_data::q0, TF_CheckTransferOut_task_data::sizeBlock, and td.

Referenced by Run().

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

◆ StepTable()

void TF_CheckTransferOut::StepTable ( )

virtual

Show table during test executing.

Implements TF_TestThread.

Definition at line 387 of file tf_checktransferout.cpp.

References TF_CheckTransferOut_task_data::BlockError, TF_CheckTransferOut_task_data::BlockOk, TF_CheckTransferOut_task_data::BlockRd, TF_CheckTransferOut_task_data::BlockWr, TF_CheckTransferOut_task_data::flagGetStatus, TF_Test::m_pTemplateEngine, TF_CheckTransferOut_task_data::RowNumber, TableEngine::SetValueTable(), td, TF_CheckTransferOut_task_data::testTime, TF_CheckTransferOut_task_data::VelocityAverage, and TF_CheckTransferOut_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, "OUT:%7.1f", td->testTime );
 
 
     td->flagGetStatus=1;
 }

◆ WaitForCalculateComplete()

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

Wait for complete calculate.

Definition at line 463 of file tf_checktransferout.cpp.

Referenced by Run().

 {
         event.wait();
 }

◆ WaitForTransferBufComplete()

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

Wait for complete data transfer.

Definition at line 405 of file tf_checktransferout.cpp.

Referenced by Run().

 {
     event.wait();
 }

Member Data Documentation

◆ td

TF_CheckTransferOut_task_data* TF_CheckTransferOut::td

< Internal data for TF_CheckTransferOut

Definition at line 24 of file tf_checktransferout.h.

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

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

host/tf_checktransferout.h
host/tf_checktransferout.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TF_CheckTransferOut()

◆ ~TF_CheckTransferOut()

Member Function Documentation

◆ CheckBuffer()

◆ CleanupInThread()

◆ GetResultInThread()

◆ GetStatus()

◆ PrepareInThread()

◆ Run()

◆ SetBuffer()

◆ StartCalculateBuf()

◆ StartWriteBuf()

◆ StepTable()

◆ WaitForCalculateComplete()

◆ WaitForTransferBufComplete()

Member Data Documentation

◆ td