URL https://opencores.org/ocsvn/pcie_ds_dma/pcie_ds_dma/trunk

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [wb_test/] [src/] [work/] [wb_teststrm.cpp] - Blame information for rev 31

Details | Compare with Previous | View Log


 
#define __VERBOSE__
 
#include <stdio.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include "utypes.h"
#include "wb_teststrm.h"
#include "cl_wbpex.h"
#include "sys/time.h"
//#include "useful.h"
 
#define BUFSIZEPKG 62
 
#define TRDIND_MODE0                                    0x0
#define TRDIND_MODE1                                    0x9
#define TRDIND_MODE2                                    0xA
#define TRDIND_SPD_CTRL                                 0x204
#define TRDIND_SPD_ADDR                                 0x205
#define TRDIND_SPD_DATA                                 0x206
 
#define TRDIND_TESTSEQ                                  0x0C
#define TRDIND_CHAN                                             0x10
#define TRDIND_FSRC                                             0x13
#define TRDIND_GAIN                                             0x15
#define TRDIND_CONTROL1                                 0x17
#define TRDIND_DELAY_CTRL                               0x1F
 
 
long GetTickCount(void)
{
    struct timeval tv;
    struct timezone tz;
    gettimeofday(&tv, &tz);
    long ret=tv.tv_sec*1000 + tv.tv_usec/1000;
    return ret;
}
 
WB_TestStrm::WB_TestStrm( char* fname,  CL_WBPEX *pex )
{
    lc_status=0;
 
    Terminate=0;
 
    pBrd=pex;
 
    SetDefault();
    GetParamFromFile( fname );
    CalculateParams();
 
    isFirstCallStep=true;
}
 
WB_TestStrm::~WB_TestStrm()
{
    pBrd->StreamDestroy( rd0.Strm );
 
}
 
void WB_TestStrm::Prepare( void )
{
 
 
    PrepareWb();
 
    rd0.trd=0;
    rd0.Strm=strmNo;
    pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, 0, 1, isCycle, isSystem, isAgreeMode );
 
}
 
void WB_TestStrm::Start( void )
{
    int res = pthread_attr_init(&attrThread_);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
    res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);
    if(res != 0) {
        fprintf(stderr, "%s\n", "Stream not started");
        return;
    }
 
}
 
void WB_TestStrm::Stop( void )
{
    Terminate=1;
    lc_status=3;
}
 
void WB_TestStrm::Step( void )
{
 
 
    rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );
 
    long currentTime = GetTickCount();
    int min, sec_all, sec;
    sec_all= currentTime-rd0.time_start;
    sec_all/=1000;
    sec=sec_all%60;
    min=sec_all/60;
 
 
    U32 status = pBrd->wb_block_read( 1, 0x10 );
    rd0.BlockWr = pBrd->wb_block_read( 1, 0x11 );
    U32 sig = pBrd->wb_block_read( 1, 0x12 );
 
    BRDC_fprintf( stdout, "%6s %3d %10d %10d %10d %10d  %9.1f %10.1f     0x%.4X  0x%.8X  %u:%.2u \r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, sig, min, sec );
 
 
 
 
}
 
int WB_TestStrm::isComplete( void )
{
    if( lc_status==4 )
        return 1;
    return 0;
}
 
void WB_TestStrm::GetResult( void )
{
    BRDC_fprintf( stderr, "\n\nResult of receiving data \n"  );
 
    BRDC_fprintf( stderr, "\n Recieved blocks :   %d \n",  rd0.BlockRd );
    BRDC_fprintf( stderr,   " Correct blocks  :   %d \n",  rd0.BlockOk );
    BRDC_fprintf( stderr,   " Incorrect blocks:   %d \n",  rd0.BlockError );
    BRDC_fprintf( stderr,   " Total errors    :   %d \n\n", rd0.TotalError );
    BRDC_fprintf( stderr,   " Speed           :   %.1f [Mbytes/s] \n", rd0.VelocityAvarage );
 
    long currentTime = GetTickCount();
    int min, sec_all, sec;
    sec_all= currentTime-rd0.time_start;
    sec_all/=1000;
    sec=sec_all%60;
    min=sec_all/60;
 
    BRDC_fprintf( stderr,   " Time of test    :   %d min %.2d sec\n\n", min, sec );
 
 
    if(rd0.BlockRd!=0 && rd0.BlockError==0)
    {
        BRDC_fprintf( stderr,"All data is correct. No error\n" );
    } else if( rd0.BlockRd==0 )
    {
        BRDC_fprintf( stderr,"Error - data is not received \n" );
 
    } else
    {
        BRDC_fprintf( stderr,"List of error:\n" );
        BRDC_fprintf( stderr,"%s\n", rd0.testBuf.report_word_error());
    }
 
    BRDC_fprintf( stderr, "\n\n" );
}
 
void* WB_TestStrm::ThreadFunc( void* lpvThreadParm )
{
    WB_TestStrm *test=(WB_TestStrm*)lpvThreadParm;
    UINT ret;
    if( !test )
        return 0;
    ret=test->Execute();
    return (void*)ret;
}
 
//! Установка параметров по умолчанию
void WB_TestStrm::SetDefault( void )
{
    int ii=0;
 
    array_cfg[ii++]=STR_CFG(  0, "CntBuffer",                    "16", (U32*)&CntBuffer, "число буферов стрима" );
    array_cfg[ii++]=STR_CFG(  0, "CntBlockInBuffer",     "512",  (U32*)&CntBlockInBuffer, "Число блоков в буфере" );
    array_cfg[ii++]=STR_CFG(  0, "SizeBlockOfWords",     "2048",  (U32*)&SizeBlockOfWords, "Размер блока в словах" );
    array_cfg[ii++]=STR_CFG(  0, "isCycle",                              "1",  (U32*)&isCycle, "1 - Циклический режим работы стрима" );
    array_cfg[ii++]=STR_CFG(  0, "isSystem",                     "1",  (U32*)&isSystem, "1 - выделение системной памяти" );
    array_cfg[ii++]=STR_CFG(  0, "isAgreeMode",                  "0",  (U32*)&isAgreeMode, "1 - согласованный режим" );
 
    array_cfg[ii++]=STR_CFG(  0, "strmNo",       "0",  (U32*)&strmNo, "Номер стрма" );
    array_cfg[ii++]=STR_CFG(  0, "isTest",       "0",  (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );
 
 
    array_cfg[ii++]=STR_CFG(  0, "FifoRdy",              "0",  (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "Cnt1", "0",  (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "Cnt2", "0",  (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );
 
    array_cfg[ii++]=STR_CFG(  0, "DataType",     "0",  (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );
 
    array_cfg[ii++]=STR_CFG(  0, "DataFix",      "0",  (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );
 
 
    max_item=ii;
 
    {
        char str[1024];
        for( unsigned ii=0; ii<max_item; ii++ )
        {
            sprintf( str, "%s  %s", array_cfg[ii].name, array_cfg[ii].def );
            GetParamFromStr( str );
        }
 
 
    }
 
}
 
//! Расчёт параметров
void WB_TestStrm::CalculateParams( void )
{
    SizeBlockOfBytes = SizeBlockOfWords * 4;                                            // Размер блока в байтах
    SizeBuferOfBytes    = CntBlockInBuffer * SizeBlockOfBytes  ;        // Размер буфера в байтах
    SizeStreamOfBytes   = CntBuffer * SizeBuferOfBytes;                         // Общий размер буфера стрима
 
    ShowParam();
}
 
//! Отображение параметров
void WB_TestStrm::ShowParam( void )
{
    TF_WorkParam::ShowParam();
 
    //BRDC_fprintf( stderr, "Size buffer: %d MB\n\n", SizeStreamOfBytes/(1024*1024) );
 
}
 
 
U32 WB_TestStrm::Execute( void )
{
    rd0.testBuf.buf_check_start( 32, 64 );
 
    pBrd->wb_block_write( 1, 8, 1 );
 
    pBrd->StreamStart( rd0.Strm );
 
    U32 val;
    val=pBrd->wb_block_read( 1, 0 );
    BRDC_fprintf( stderr, "ID=0x%.4X \n", val );
 
    val=pBrd->wb_block_read( 1, 1 );
    BRDC_fprintf( stderr, "VER=0x%.4X \n", val );
 
    val=pBrd->wb_block_read( 1, 8 );
    BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val );
 
    pBrd->wb_block_write( 1, 8, 0 );
 
    BlockMode = DataType <<8;
    BlockMode |= DataFix <<7;
 
 
    U32 size = SizeBlockOfWords/1024;
    //if( isTestCtrl )
    {
        pBrd->wb_block_write( 1, 9, size );
        pBrd->wb_block_write( 1, 8, BlockMode | 0x20 );
    }
 
 
    val=pBrd->wb_block_read( 1, 8 );
    BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val );
 
    rd0.time_last=rd0.time_start=GetTickCount();
 
 
    for( ; ; )
    {
        if( Terminate )
        {
            break;
        }
 
        ReceiveData( &rd0 );
        //Sleep( 100 );
    }
 
    pBrd->StreamStop( rd0.Strm );
    Sleep( 10 );
 
    lc_status=4;
    return 1;
}
 
 
 
 
void WB_TestStrm::ReceiveData(  ParamExchange *pr )
{
    U32 *ptr;
    U32 *ptrBlock;
    U32 mode=0;
    mode |= pr->DataType<<8;
    mode |= pr->DataFix<<7;
 
    int ret;
    int kk;
 
 
    for( kk=0; kk<16; kk++ )
    {
        ret=pBrd->StreamGetBuf( pr->Strm, &ptr );
        //ret=0;
        if( ret )
        { // check buffer
 
                for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )
                {
                    ptrBlock=ptr+ii*SizeBlockOfWords;
 
                    if( 1==isTest )
                        pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );
                    //int a=0;
                    else if( 2==isTest )
                        pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );
                    else if( 4==isTest )
                        pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );
 
                    pr->BlockRd++;
                }
                if( isAgreeMode )
                {
                    pBrd->StreamGetBufDone( pr->Strm );
                }
 
        } else
        {
            //Sleep( 0 );
            pr->freeCycle++;
            break;
        }
    }
    //Sleep( 0 );
 
    long currentTime = GetTickCount();
    if( (currentTime - pr->time_last)>4000 )
    {
        float t1 = currentTime - pr->time_last;
        float t2 = currentTime - pr->time_start;
        float v = 1000.0*(pr->BlockRd-pr->BlockLast)*SizeBlockOfBytes/t1;
        v/=1024*1024;
        pr->VelocityCurrent=v;
 
        v = 1000.0*(pr->BlockRd)*SizeBlockOfBytes/t2;
        v/=1024*1024;
        pr->VelocityAvarage=v;
        pr->time_last = currentTime;
        pr->BlockLast = pr->BlockRd;
        pr->freeCycleZ=pr->freeCycle;
        pr->freeCycle=0;
 
    }
 
}
 
 
void WB_TestStrm::PrepareWb( void )
{
/*
    BRDC_fprintf( stderr, "\nPrepare TEST_GENERATE\n" );
 
 
 
    BlockMode = DataType <<8;
    BlockMode |= DataFix <<7;
 
    //if( isTestCtrl )
    {
        pBrd->wb_block_write( 1, 9, 1 );
        pBrd->wb_block_write( 1, 8, BlockMode );
    }
*/
 
}
 
 
 

Line No.	Rev	Author	Line
1	2	dsmv
2	30	dsmv	`#define __VERBOSE__`
3	2	dsmv
4			`#include <stdio.h>`
5			`#include <fcntl.h>`
6			`#include <pthread.h>`
7			`#include <unistd.h>`
8			`#include <sys/types.h>`
9			`#include <sys/stat.h>`
10			`#include <pthread.h>`
11			`#include "utypes.h"`
12			`#include "wb_teststrm.h"`
13			`#include "cl_wbpex.h"`
14	31	dsmv	`#include "sys/time.h"`
15	2	dsmv	`//#include "useful.h"`
16
17			`#define BUFSIZEPKG 62`
18
19			`#define TRDIND_MODE0 0x0`
20			`#define TRDIND_MODE1 0x9`
21			`#define TRDIND_MODE2 0xA`
22			`#define TRDIND_SPD_CTRL 0x204`
23			`#define TRDIND_SPD_ADDR 0x205`
24			`#define TRDIND_SPD_DATA 0x206`
25
26			`#define TRDIND_TESTSEQ 0x0C`
27			`#define TRDIND_CHAN 0x10`
28			`#define TRDIND_FSRC 0x13`
29			`#define TRDIND_GAIN 0x15`
30			`#define TRDIND_CONTROL1 0x17`
31			`#define TRDIND_DELAY_CTRL 0x1F`
32
33
34	31	dsmv	`long GetTickCount(void)`
35			`{`
36			`struct timeval tv;`
37			`struct timezone tz;`
38			`gettimeofday(&tv, &tz);`
39			`long ret=tv.tv_sec*1000 + tv.tv_usec/1000;`
40			`return ret;`
41			`}`
42
43	2	dsmv	`WB_TestStrm::WB_TestStrm( char* fname, CL_WBPEX *pex )`
44			`{`
45			`lc_status=0;`
46
47			`Terminate=0;`
48
49			`pBrd=pex;`
50
51			`SetDefault();`
52			`GetParamFromFile( fname );`
53			`CalculateParams();`
54
55			`isFirstCallStep=true;`
56			`}`
57
58			`WB_TestStrm::~WB_TestStrm()`
59			`{`
60			`pBrd->StreamDestroy( rd0.Strm );`
61
62			`}`
63
64			`void WB_TestStrm::Prepare( void )`
65			`{`
66
67
68	19	dsmv	`PrepareWb();`
69	2	dsmv
70	31	dsmv	`rd0.trd=0;`
71	2	dsmv	`rd0.Strm=strmNo;`
72	31	dsmv	`pBrd->StreamInit( rd0.Strm, CntBuffer, SizeBuferOfBytes, 0, 1, isCycle, isSystem, isAgreeMode );`
73	2	dsmv
74			`}`
75
76			`void WB_TestStrm::Start( void )`
77			`{`
78			`int res = pthread_attr_init(&attrThread_);`
79			`if(res != 0) {`
80			`fprintf(stderr, "%s\n", "Stream not started");`
81			`return;`
82			`}`
83
84			`res = pthread_attr_setdetachstate(&attrThread_, PTHREAD_CREATE_JOINABLE);`
85			`if(res != 0) {`
86			`fprintf(stderr, "%s\n", "Stream not started");`
87			`return;`
88			`}`
89
90			`res = pthread_create(&hThread, &attrThread_, ThreadFunc, this);`
91			`if(res != 0) {`
92			`fprintf(stderr, "%s\n", "Stream not started");`
93			`return;`
94			`}`
95
96			`}`
97
98			`void WB_TestStrm::Stop( void )`
99			`{`
100			`Terminate=1;`
101			`lc_status=3;`
102			`}`
103
104			`void WB_TestStrm::Step( void )`
105			`{`
106
107
108			`rd0.testBuf.check_result( &rd0.BlockOk , &rd0.BlockError, NULL, NULL, NULL );`
109
110	31	dsmv	`long currentTime = GetTickCount();`
111			`int min, sec_all, sec;`
112			`sec_all= currentTime-rd0.time_start;`
113			`sec_all/=1000;`
114			`sec=sec_all%60;`
115			`min=sec_all/60;`
116	2	dsmv
117	31	dsmv
118	30	dsmv	`U32 status = pBrd->wb_block_read( 1, 0x10 );`
119			`rd0.BlockWr = pBrd->wb_block_read( 1, 0x11 );`
120			`U32 sig = pBrd->wb_block_read( 1, 0x12 );`
121	2	dsmv
122	31	dsmv	`BRDC_fprintf( stdout, "%6s %3d %10d %10d %10d %10d %9.1f %10.1f 0x%.4X 0x%.8X %u:%.2u \r", "TRD :", rd0.trd, rd0.BlockWr, rd0.BlockRd, rd0.BlockOk, rd0.BlockError, rd0.VelocityCurrent, rd0.VelocityAvarage, status, sig, min, sec );`
123	2	dsmv
124
125
126	19	dsmv
127	2	dsmv	`}`
128
129			`int WB_TestStrm::isComplete( void )`
130			`{`
131	31	dsmv	`if( lc_status==4 )`
132	2	dsmv	`return 1;`
133			`return 0;`
134			`}`
135
136			`void WB_TestStrm::GetResult( void )`
137			`{`
138	31	dsmv	`BRDC_fprintf( stderr, "\n\nResult of receiving data \n" );`
139	2	dsmv
140	31	dsmv	`BRDC_fprintf( stderr, "\n Recieved blocks : %d \n", rd0.BlockRd );`
141			`BRDC_fprintf( stderr, " Correct blocks : %d \n", rd0.BlockOk );`
142			`BRDC_fprintf( stderr, " Incorrect blocks: %d \n", rd0.BlockError );`
143			`BRDC_fprintf( stderr, " Total errors : %d \n\n", rd0.TotalError );`
144			`BRDC_fprintf( stderr, " Speed : %.1f [Mbytes/s] \n", rd0.VelocityAvarage );`
145	2	dsmv
146	31	dsmv	`long currentTime = GetTickCount();`
147			`int min, sec_all, sec;`
148			`sec_all= currentTime-rd0.time_start;`
149			`sec_all/=1000;`
150			`sec=sec_all%60;`
151			`min=sec_all/60;`
152
153			`BRDC_fprintf( stderr, " Time of test : %d min %.2d sec\n\n", min, sec );`
154
155
156			`if(rd0.BlockRd!=0 && rd0.BlockError==0)`
157			`{`
158			`BRDC_fprintf( stderr,"All data is correct. No error\n" );`
159			`} else if( rd0.BlockRd==0 )`
160			`{`
161			`BRDC_fprintf( stderr,"Error - data is not received \n" );`
162
163			`} else`
164			`{`
165			`BRDC_fprintf( stderr,"List of error:\n" );`
166			`BRDC_fprintf( stderr,"%s\n", rd0.testBuf.report_word_error());`
167			`}`
168
169	2	dsmv	`BRDC_fprintf( stderr, "\n\n" );`
170			`}`
171
172			`void* WB_TestStrm::ThreadFunc( void* lpvThreadParm )`
173			`{`
174			`WB_TestStrm test=(WB_TestStrm)lpvThreadParm;`
175			`UINT ret;`
176			`if( !test )`
177			`return 0;`
178			`ret=test->Execute();`
179			`return (void*)ret;`
180			`}`
181
182			`//! Установка параметров по умолчанию`
183			`void WB_TestStrm::SetDefault( void )`
184			`{`
185			`int ii=0;`
186
187			`array_cfg[ii++]=STR_CFG( 0, "CntBuffer", "16", (U32*)&CntBuffer, "число буферов стрима" );`
188			`array_cfg[ii++]=STR_CFG( 0, "CntBlockInBuffer", "512", (U32*)&CntBlockInBuffer, "Число блоков в буфере" );`
189			`array_cfg[ii++]=STR_CFG( 0, "SizeBlockOfWords", "2048", (U32*)&SizeBlockOfWords, "Размер блока в словах" );`
190			`array_cfg[ii++]=STR_CFG( 0, "isCycle", "1", (U32*)&isCycle, "1 - Циклический режим работы стрима" );`
191			`array_cfg[ii++]=STR_CFG( 0, "isSystem", "1", (U32*)&isSystem, "1 - выделение системной памяти" );`
192			`array_cfg[ii++]=STR_CFG( 0, "isAgreeMode", "0", (U32*)&isAgreeMode, "1 - согласованный режим" );`
193
194			`array_cfg[ii++]=STR_CFG( 0, "strmNo", "0", (U32*)&strmNo, "Номер стрма" );`
195			`array_cfg[ii++]=STR_CFG( 0, "isTest", "0", (U32*)&isTest, "0 - нет, 1 - проверка псевдослучайной последовательности, 2 - проверка тестовой последовательности" );`
196
197
198			`array_cfg[ii++]=STR_CFG( 0, "FifoRdy", "0", (U32*)&isFifoRdy, "1 - генератор тестовой последовательности анализирует флаг готовности FIFO" );`
199
200			`array_cfg[ii++]=STR_CFG( 0, "Cnt1", "0", (U32*)&Cnt1, "Число тактов записи в FIFO, 0 - постоянная запись в FIFO" );`
201
202			`array_cfg[ii++]=STR_CFG( 0, "Cnt2", "0", (U32*)&Cnt2, "Число тактов паузы при записи в FIFO" );`
203
204			`array_cfg[ii++]=STR_CFG( 0, "DataType", "0", (U32*)&DataType, "Тип данных при фиксированном типе блока, 6 - счётчик, 8 - псевдослучайная последовательность" );`
205
206			`array_cfg[ii++]=STR_CFG( 0, "DataFix", "0", (U32*)&DataFix, "1 - фиксированный тип блока, 0 - данные в блоке записят от номера блока" );`
207
208
209			`max_item=ii;`
210
211			`{`
212			`char str[1024];`
213			`for( unsigned ii=0; ii<max_item; ii++ )`
214			`{`
215			`sprintf( str, "%s %s", array_cfg[ii].name, array_cfg[ii].def );`
216			`GetParamFromStr( str );`
217			`}`
218
219
220			`}`
221
222			`}`
223
224			`//! Расчёт параметров`
225			`void WB_TestStrm::CalculateParams( void )`
226			`{`
227			`SizeBlockOfBytes = SizeBlockOfWords * 4; // Размер блока в байтах`
228			`SizeBuferOfBytes = CntBlockInBuffer * SizeBlockOfBytes ; // Размер буфера в байтах`
229			`SizeStreamOfBytes = CntBuffer * SizeBuferOfBytes; // Общий размер буфера стрима`
230
231			`ShowParam();`
232			`}`
233
234			`//! Отображение параметров`
235			`void WB_TestStrm::ShowParam( void )`
236			`{`
237			`TF_WorkParam::ShowParam();`
238
239	31	dsmv	`//BRDC_fprintf( stderr, "Size buffer: %d MB\n\n", SizeStreamOfBytes/(1024*1024) );`
240	2	dsmv
241			`}`
242
243
244			`U32 WB_TestStrm::Execute( void )`
245			`{`
246			`rd0.testBuf.buf_check_start( 32, 64 );`
247
248	30	dsmv	`pBrd->wb_block_write( 1, 8, 1 );`
249
250	19	dsmv	`pBrd->StreamStart( rd0.Strm );`
251
252			`U32 val;`
253			`val=pBrd->wb_block_read( 1, 0 );`
254			`BRDC_fprintf( stderr, "ID=0x%.4X \n", val );`
255
256			`val=pBrd->wb_block_read( 1, 1 );`
257			`BRDC_fprintf( stderr, "VER=0x%.4X \n", val );`
258
259			`val=pBrd->wb_block_read( 1, 8 );`
260			`BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val );`
261
262	30	dsmv	`pBrd->wb_block_write( 1, 8, 0 );`
263	19	dsmv
264	31	dsmv	`BlockMode = DataType <<8;`
265			`BlockMode \|= DataFix <<7;`
266
267
268			`U32 size = SizeBlockOfWords/1024;`
269			`//if( isTestCtrl )`
270			`{`
271			`pBrd->wb_block_write( 1, 9, size );`
272			`pBrd->wb_block_write( 1, 8, BlockMode \| 0x20 );`
273			`}`
274
275
276	19	dsmv	`val=pBrd->wb_block_read( 1, 8 );`
277			`BRDC_fprintf( stderr, "GEN_CTRL=0x%.4X \n", val );`
278
279	31	dsmv	`rd0.time_last=rd0.time_start=GetTickCount();`
280	2	dsmv
281
282			`for( ; ; )`
283			`{`
284			`if( Terminate )`
285			`{`
286			`break;`
287			`}`
288
289			`ReceiveData( &rd0 );`
290			`//Sleep( 100 );`
291			`}`
292	31	dsmv
293	2	dsmv	`pBrd->StreamStop( rd0.Strm );`
294			`Sleep( 10 );`
295
296			`lc_status=4;`
297			`return 1;`
298			`}`
299
300
301
302
303			`void WB_TestStrm::ReceiveData( ParamExchange *pr )`
304			`{`
305			`U32 *ptr;`
306			`U32 *ptrBlock;`
307			`U32 mode=0;`
308			`mode \|= pr->DataType<<8;`
309			`mode \|= pr->DataFix<<7;`
310
311			`int ret;`
312			`int kk;`
313
314
315			`for( kk=0; kk<16; kk++ )`
316			`{`
317			`ret=pBrd->StreamGetBuf( pr->Strm, &ptr );`
318	19	dsmv	`//ret=0;`
319	2	dsmv	`if( ret )`
320	31	dsmv	`{ // check buffer`
321	2	dsmv
322			`for( unsigned ii=0; ii<CntBlockInBuffer; ii++ )`
323			`{`
324			`ptrBlock=ptr+ii*SizeBlockOfWords;`
325
326			`if( 1==isTest )`
327			`pr->testBuf.buf_check_psd( ptrBlock, SizeBlockOfWords );`
328			`//int a=0;`
329			`else if( 2==isTest )`
330			`pr->testBuf.buf_check( ptrBlock, pr->BlockRd, SizeBlockOfWords, BlockMode );`
331			`else if( 4==isTest )`
332			`pr->testBuf.buf_check_inv( ptrBlock, SizeBlockOfWords );`
333
334			`pr->BlockRd++;`
335			`}`
336			`if( isAgreeMode )`
337			`{`
338			`pBrd->StreamGetBufDone( pr->Strm );`
339			`}`
340
341			`} else`
342			`{`
343			`//Sleep( 0 );`
344			`pr->freeCycle++;`
345			`break;`
346			`}`
347			`}`
348			`//Sleep( 0 );`
349
350	31	dsmv	`long currentTime = GetTickCount();`
351	2	dsmv	`if( (currentTime - pr->time_last)>4000 )`
352			`{`
353			`float t1 = currentTime - pr->time_last;`
354			`float t2 = currentTime - pr->time_start;`
355			`float v = 1000.0(pr->BlockRd-pr->BlockLast)SizeBlockOfBytes/t1;`
356			`v/=1024*1024;`
357			`pr->VelocityCurrent=v;`
358
359			`v = 1000.0(pr->BlockRd)SizeBlockOfBytes/t2;`
360			`v/=1024*1024;`
361			`pr->VelocityAvarage=v;`
362			`pr->time_last = currentTime;`
363			`pr->BlockLast = pr->BlockRd;`
364			`pr->freeCycleZ=pr->freeCycle;`
365			`pr->freeCycle=0;`
366
367			`}`
368
369			`}`
370
371
372	19	dsmv	`void WB_TestStrm::PrepareWb( void )`
373	2	dsmv	`{`
374	31	dsmv	`/*`
375	19	dsmv	`BRDC_fprintf( stderr, "\nPrepare TEST_GENERATE\n" );`
376	2	dsmv
377
378
379			`BlockMode = DataType <<8;`
380			`BlockMode \|= DataFix <<7;`
381
382	19	dsmv	`//if( isTestCtrl )`
383			`{`
384			`pBrd->wb_block_write( 1, 9, 1 );`
385	31	dsmv	`pBrd->wb_block_write( 1, 8, BlockMode );`
386	19	dsmv	`}`
387	2	dsmv	`*/`
388
389			`}`
390
391
392

Browse

Tools

Subversion Repositories pcie_ds_dma

[/] [pcie_ds_dma/] [trunk/] [soft/] [linux/] [application/] [wb_test/] [src/] [work/] [wb_teststrm.cpp] - Blame information for rev 31