source: soft/giet_vm/applications/classif/main.c @ 543

Last change on this file since 543 was 542, checked in by bellefin, 10 years ago

Using the heap_init() function
File size: 24.2 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////////
2// File   : main.c   (for classif application)
3// Date   : november 2014
4// author : Alain Greiner
5///////////////////////////////////////////////////////////////////////////////////////
6// This multi-threaded application takes a stream of Gigabit Ethernet packets,
7// and makes packet analysis and classification, based on the source MAC address.
8// It uses the NIC peripheral, and the distributed kernel chbufs accessed by the CMA
9// component to receive and send packets on the Gigabit Ethernet port.
10//
11// It can run on architectures containing up to 16 * 16 clusters,
12// and up to 8 processors per cluster.
13//
14// This application is described as a TCG (Task and Communication Graph)
15// containing (N+2) tasks per cluster:
16// - one "load" task
17// - one "store" task
18// - N "analyse" tasks
19// The containers are distributed (N+2 containers per cluster):
20// - one RX container (part of the kernel rx_chbuf), in the kernel heap.
21// - one TX container (part of the kernel tx-chbuf), in the kernel heap.
22// - N working containers (one per analysis task), in the user heap.
23// In each cluster, the "load", analysis" and "store" tasks communicates through
24// three local MWMR fifos:
25// - fifo_l2a : tranfer a full container from "load" to "analyse" task.
26// - fifo_a2s : transfer a full container from "analyse" to "store" task.
27// - fifo_s2l : transfer an empty container from "store" to "load" task.
28// For each fifo, one item is a 32 bits word defining the index of an
29// available working container.
30// The pointers on the working containers, and the pointers on the MWMR fifos
31// are global arrays stored in cluster[0][0].
32// a local MWMR fifo containing NB_PROCS_MAX containers (one item = one container).
33// The MWMR fifo descriptors array is defined as a global variable in cluster[0][0].
34//
35// Initialisation is done in three steps by the "load" & "store" tasks:
36// - Task "load" in cluster[0][0] initialises the heaps in all clusters. Other tasks
37//   are waiting on the global_sync synchronisation variable.
38// - Then task "load" in cluster[0][0] initialises the barrier between all "load"
39//   tasks, allocates NIC & CMA RX channel, and starts the NIC_CMA RX transfer.
40//   Other "load" tasks are waiting on the load_sync synchronisation variable.
41//   Task "store" in cluster[0][0] initialises the barrier between all "store" tasks,
42//   allocates NIC & CMA TX channels, and starts the NIC_CMA TX transfer.
43//   Other "store" tasks are waiting on the store_sync synchronisation variable.
44// - When this global initialisation is completed, the "load" task in all clusters
45//   allocates the working containers and the MWMR fifos descriptors from the
46//   user local heap. In each cluster, the "analyse" and "store" tasks are waiting
47//   the local initialisation completion on the local_sync[x][y] variables.
48//
49// When initialisation is completed, all tasks loop on containers:
50// 1) The "load" task get an empty working container from the fifo_s2l,
51//    transfer one container from the kernel rx_chbuf to this user container,
52//    and transfer ownership of this container to one "analysis" task by writing
53//    into the fifo_l2a.   
54// 2) The "analyse" task get one working container from the fifo_l2a, analyse
55//    each packet header, compute the packet type (depending on the SRC MAC address),
56//    increment the correspondint classification counter, and transpose the SRC
57//    and the DST MAC addresses fot TX tranmission.
58// 3) The "store" task transfer get a full working container from the fifo_a2s,
59//    transfer this user container content to the the kernel tx_chbuf,
60//    and transfer ownership of this empty container to the "load" task by writing
61//    into the fifo_s2l.   
62//     
63// Instrumentation results display is done by the "store" task in cluster[0][0]
64// when all "store" tasks completed the number of clusters specified by the
65// CONTAINERS_MAX parameter.
66///////////////////////////////////////////////////////////////////////////////////////
67
68#include "stdio.h"
69#include "user_barrier.h"
70#include "malloc.h"
71#include "user_lock.h"
72#include "mwmr_channel.h"
73
74#define X_SIZE_MAX      16
75#define Y_SIZE_MAX      16
76#define NPROCS_MAX      8
77#define CONTAINERS_MAX  50
78#define VERBOSE_ANALYSE 0
79
80///////////////////////////////////////////////////////////////////////////////////////
81//    Global variables
82// The MWMR channels (descriptors and buffers), as well as the working containers
83// used by the "analysis" tasks are distributed in clusters.
84// But the pointers on these distributed structures are shared arrays
85// stored in cluster[0][0].
86///////////////////////////////////////////////////////////////////////////////////////
87
88// pointers on distributed containers
89unsigned int*       container[X_SIZE_MAX][Y_SIZE_MAX][NPROCS_MAX-2]; 
90
91// pointers on distributed mwmr fifos containing : temp[x][y][l] container descriptors
92mwmr_channel_t*     mwmr_l2a[X_SIZE_MAX][Y_SIZE_MAX]; 
93mwmr_channel_t*     mwmr_a2s[X_SIZE_MAX][Y_SIZE_MAX];
94mwmr_channel_t*     mwmr_s2l[X_SIZE_MAX][Y_SIZE_MAX]; 
95
96// local synchros signaling local MWMR fifos initialisation completion
97volatile unsigned int        local_sync[X_SIZE_MAX][Y_SIZE_MAX]; 
98
99// global synchro signaling global initialisation completion
100volatile unsigned int        global_sync = 0;
101volatile unsigned int        load_sync   = 0; 
102volatile unsigned int        store_sync  = 0; 
103
104// instrumentation counters
105unsigned int        counter[16];
106
107// distributed barrier between "load" tasks
108giet_sqt_barrier_t  rx_barrier;
109
110// distributed barrier between "store" tasks
111giet_sqt_barrier_t  tx_barrier;
112
113// NIC_RX and NIC_TX channel index
114unsigned int        nic_rx_channel;
115unsigned int        nic_tx_channel;
116
117/////////////////////////////////////////
118__attribute__ ((constructor)) void load()
119/////////////////////////////////////////
120{
121    // each "load" task get platform parameters
122    unsigned int    x_size;                     // number of clusters in a row
123    unsigned int    y_size;                     // number of clusters in a column
124    unsigned int    nprocs;                     // number of processors per cluster
125    giet_procs_number( &x_size, &y_size, &nprocs );
126
127    giet_assert( (x_size <= X_SIZE_MAX) && 
128                 (y_size <= Y_SIZE_MAX) && 
129                 (nprocs <= NPROCS_MAX) , 
130                 "[CLASSIF ERROR] illegal platform parameters" );
131
132    // each "load" task get processor identifiers
133    unsigned int    x;
134    unsigned int    y;
135    unsigned int    l;
136    giet_proc_xyp( &x, &y, &l );
137
138    // "load" task[0][0]
139    // - initialises the heap in every cluster
140    // - initialises barrier between all load tasks,
141    // - allocates the NIC & CMA RX channels, and start the NIC_CMA RX transfer.
142    // Other "load" tasks wait completion
143    if ( (x==0) && (y==0) )
144    {
145        giet_shr_printf("\n*** Task load on P[%d][%d][%d] starts at cycle %d\n"
146                        "  x_size = %d / y_size = %d / nprocs = %d\n",
147                        x , y , l , giet_proctime() , x_size, y_size, nprocs );
148
149    unsigned int xid;  // x cluster coordinate index
150    unsigned int yid;  // y cluster coordinate index
151
152    for ( xid = 0 ; xid < x_size ; xid++ )
153      {
154        for ( yid = 0 ; yid < y_size ; yid++ )
155          {
156            heap_init( xid, yid );
157          }
158      }
159   
160        global_sync = 1;
161
162        sqt_barrier_init( &rx_barrier, x_size , y_size , 1 );
163        nic_rx_channel = giet_nic_rx_alloc( x_size , y_size );
164        giet_nic_rx_start( nic_rx_channel );
165        load_sync = 1;
166    }
167    else
168    {
169        while ( load_sync == 0 ) asm volatile ("nop");
170    }   
171
172    // each load tasks allocates containers[x][y][n] (from local heap)
173    // and register pointers in the local stack
174    unsigned int   n;
175    unsigned int*  cont[NPROCS_MAX-2]; 
176    unsigned int   analysis_tasks = nprocs-2;
177
178    for ( n = 0 ; n < analysis_tasks ; n++ )
179    {
180        container[x][y][n] = malloc( 4096 );
181        cont[n]            = container[x][y][n];
182    }
183   
184    // each load task allocates data buffers for mwmr fifos (from local heap)
185    unsigned int*  data_l2a = malloc( analysis_tasks<<2 );
186    unsigned int*  data_a2s = malloc( analysis_tasks<<2 );
187    unsigned int*  data_s2l = malloc( analysis_tasks<<2 );
188
189    // each load task allocates mwmr fifos descriptors (from local heap)
190    mwmr_l2a[x][y] = malloc( sizeof(mwmr_channel_t) );
191    mwmr_a2s[x][y] = malloc( sizeof(mwmr_channel_t) );
192    mwmr_s2l[x][y] = malloc( sizeof(mwmr_channel_t) );
193
194    // each load task registers local pointers on mwmr fifos in local stack
195    mwmr_channel_t* fifo_l2a = mwmr_l2a[x][y];
196    mwmr_channel_t* fifo_a2s = mwmr_a2s[x][y];
197    mwmr_channel_t* fifo_s2l = mwmr_s2l[x][y];
198
199    // each load task initialises local mwmr fifos descriptors
200    // ( width = 4 bytes / depth = number of analysis tasks )
201    mwmr_init( fifo_l2a , data_l2a , 1 , analysis_tasks );
202    mwmr_init( fifo_a2s , data_a2s , 1 , analysis_tasks );
203    mwmr_init( fifo_s2l , data_s2l , 1 , analysis_tasks );
204
205   
206    // each load task initialises local containers as empty in fifo_s2l
207    for ( n = 0 ; n < analysis_tasks ; n++ ) mwmr_write( fifo_s2l , &n , 1 );
208
209    // each load task[x][y] signals mwmr fifos initialisation completion
210    // to other tasks in same cluster[x][y]
211    local_sync[x][y] = 1;
212
213    // load task[0][0] displays status
214    if ( (x==0) && (y==0) )
215    giet_shr_printf("\n*** Task load on P[%d,%d,%d] enters main loop at cycle %d\n"
216                    "      nic_rx_channel = %d / nic_tx_channel = %d\n"
217                    "      &mwmr_l2a  = %x / &data_l2a  = %x\n"
218                    "      &mwmr_a2s  = %x / &data_a2s  = %x\n"
219                    "      &mwmr_s2l  = %x / &data_s2l  = %x\n"
220                    "      &cont[0]   = %x\n"
221                    "      x_size = %d / y_size = %d / nprocs = %d\n",
222                    x , y , l , giet_proctime(), 
223                    nic_rx_channel , nic_tx_channel,
224                    (unsigned int)fifo_l2a, (unsigned int)data_l2a,
225                    (unsigned int)fifo_a2s, (unsigned int)data_a2s,
226                    (unsigned int)fifo_s2l, (unsigned int)data_s2l,
227                    (unsigned int)cont[0],
228                    x_size, y_size, nprocs );
229 
230    /////////////////////////////////////////////////////////////
231    // All load tasks enter the main loop (on containers)
232    unsigned int  count = 0;     // loaded containers count
233    unsigned int  index;         // available container index
234    unsigned int* temp;          // pointer on available container
235
236    while ( count < CONTAINERS_MAX ) 
237    { 
238        // get one empty container index from fifo_s2l
239        mwmr_read( fifo_s2l , &index , 1 );
240        temp = cont[index];
241
242        // get one container from  kernel rx_chbuf
243        giet_nic_rx_move( nic_rx_channel, temp );
244
245        // get packets number
246        unsigned int npackets = temp[0] & 0x0000FFFF;
247        unsigned int nwords   = temp[0] >> 16;
248
249        if ( (x==0) && (y==0) )
250        giet_shr_printf("\n*** Task load on P[%d,%d,%d] get container %d at cycle %d"
251                        " : %d packets / %d words\n",
252                        x, y, l, count, giet_proctime(), npackets, nwords );
253
254        // put the full container index to fifo_l2a
255        mwmr_write( fifo_l2a, &index , 1 );
256
257        count++;
258    }
259
260    // all "load" tasks synchronise before stats
261    sqt_barrier_wait( &rx_barrier );
262
263    // "load" task[0][0] stops the NIC_CMA RX transfer and displays stats
264    if ( (x==0) && (y==0) ) 
265    {
266        giet_nic_rx_stop( nic_rx_channel );
267        giet_nic_rx_stats( nic_rx_channel );
268    }
269
270    // all "load" task exit
271    giet_exit("Task completed");
272 
273} // end load()
274
275
276//////////////////////////////////////////
277__attribute__ ((constructor)) void store()
278//////////////////////////////////////////
279{
280    // each "load" task get platform parameters
281    unsigned int    x_size;                                             // number of clusters in row
282    unsigned int    y_size;                     // number of clusters in a column
283    unsigned int    nprocs;                     // number of processors per cluster
284    giet_procs_number( &x_size, &y_size, &nprocs );
285
286    // get processor identifiers
287    unsigned int    x;
288    unsigned int    y;
289    unsigned int    l;
290    giet_proc_xyp( &x, &y, &l );
291
292    // "Store" tasks wait completion of heaps initialization
293    while ( global_sync == 0 ) asm volatile ("nop");
294
295    // "store" task[0][0] initialises the barrier between all "store" tasks,
296    // allocates NIC & CMA TX channels, and starts the NIC_CMA TX transfer.
297    // Other "store" tasks wait completion.
298    if ( (x==0) && (y==0) )
299    {
300        giet_shr_printf("\n*** Task store on P[%d][%d][%d] starts at cycle %d\n"
301                        "  x_size = %d / y_size = %d / nprocs = %d\n",
302                        x , y , l , giet_proctime() , x_size, y_size, nprocs );
303 
304        sqt_barrier_init( &tx_barrier , x_size , y_size , 1 );
305        nic_tx_channel = giet_nic_tx_alloc( x_size , y_size );
306        giet_nic_tx_start( nic_tx_channel );
307        store_sync = 1;
308    }
309    else
310    {
311        while ( store_sync == 0 ) asm volatile ("nop");
312    }   
313
314    // all "store" tasks wait mwmr channels initialisation
315    while ( local_sync[x][y] == 0 ) asm volatile ("nop");
316
317    // each "store" tasks register pointers on working containers in local stack
318    unsigned int   n;
319    unsigned int   analysis_tasks = nprocs-2;
320    unsigned int*  cont[NPROCS_MAX-2]; 
321
322    for ( n = 0 ; n < analysis_tasks ; n++ )
323    {
324        cont[n] = container[x][y][n];
325    }
326   
327    // all "store" tasks register pointers on mwmr fifos in local stack
328    mwmr_channel_t* fifo_l2a = mwmr_l2a[x][y];
329    mwmr_channel_t* fifo_a2s = mwmr_a2s[x][y];
330    mwmr_channel_t* fifo_s2l = mwmr_s2l[x][y];
331
332    // "store" task[0][0] displays status
333    if ( (x==0) && (y==0) )
334    giet_shr_printf("\n*** Task store on P[%d,%d,%d] enters main loop at cycle %d\n"
335                    "      &mwmr_l2a  = %x\n"
336                    "      &mwmr_a2s  = %x\n"
337                    "      &mwmr_s2l  = %x\n"
338                    "      &cont[0]   = %x\n",
339                    x , y , l , giet_proctime(), 
340                    (unsigned int)fifo_l2a,
341                    (unsigned int)fifo_a2s,
342                    (unsigned int)fifo_s2l,
343                    (unsigned int)cont[0] );
344
345
346    /////////////////////////////////////////////////////////////
347    // all "store" tasks enter the main loop (on containers)
348    unsigned int count = 0;     // stored containers count
349    unsigned int index;         // empty container index
350    unsigned int* temp;         // pointer on empty container
351
352    while ( count < CONTAINERS_MAX ) 
353    { 
354        // get one working container index from fifo_a2s
355        mwmr_read( fifo_a2s , &index , 1 );
356        temp = cont[index];
357
358        // put one container to  kernel tx_chbuf
359        giet_nic_tx_move( nic_tx_channel, temp );
360
361        // get packets number
362        unsigned int npackets = temp[0] & 0x0000FFFF;
363        unsigned int nwords   = temp[0] >> 16;
364
365        if ( (x==0) && (y==0) )
366        giet_shr_printf("\n*** Task store on P[%d,%d,%d] get container %d at cycle %d"
367                        " : %d packets / %d words\n",
368                        x, y, l, count, giet_proctime(), npackets, nwords );
369
370        // put the working container index to fifo_s2l
371        mwmr_write( fifo_s2l, &index , 1 );
372
373        count++;
374    }
375
376    // all "store" tasks synchronise before result display
377    sqt_barrier_wait( &tx_barrier );
378
379    // "store" task[0,0] stops NIC_CMA TX transfer and displays results
380    if ( (x==0) && (y==0) )
381    {
382        giet_nic_tx_stop( nic_tx_channel );
383
384        giet_shr_printf("\n@@@@ Classification Results @@@\n"
385                        " - TYPE 0 : %d packets\n"
386                        " - TYPE 1 : %d packets\n"
387                        " - TYPE 2 : %d packets\n"
388                        " - TYPE 3 : %d packets\n"
389                        " - TYPE 4 : %d packets\n"
390                        " - TYPE 5 : %d packets\n"
391                        " - TYPE 6 : %d packets\n"
392                        " - TYPE 7 : %d packets\n"
393                        " - TYPE 8 : %d packets\n"
394                        " - TYPE 9 : %d packets\n"
395                        " - TYPE A : %d packets\n"
396                        " - TYPE B : %d packets\n"
397                        " - TYPE C : %d packets\n"
398                        " - TYPE D : %d packets\n"
399                        " - TYPE E : %d packets\n"
400                        " - TYPE F : %d packets\n"
401                        "    TOTAL = %d packets\n",
402                        counter[0x0], counter[0x1], counter[0x2], counter[0x3],
403                        counter[0x4], counter[0x5], counter[0x6], counter[0x7],
404                        counter[0x8], counter[0x9], counter[0xA], counter[0xB],
405                        counter[0xC], counter[0xD], counter[0xE], counter[0xF],
406                        counter[0x0]+ counter[0x1]+ counter[0x2]+ counter[0x3]+
407                        counter[0x4]+ counter[0x5]+ counter[0x6]+ counter[0x7]+
408                        counter[0x8]+ counter[0x9]+ counter[0xA]+ counter[0xB]+
409                        counter[0xC]+ counter[0xD]+ counter[0xE]+ counter[0xF] );
410
411        giet_nic_tx_stats( nic_tx_channel );
412    }
413
414    // all "store" task exit
415    giet_exit("Task completed");
416
417} // end store()
418
419
420////////////////////////////////////////////
421__attribute__ ((constructor)) void analyse()
422////////////////////////////////////////////
423{
424    // each "load" task get platform parameters
425    unsigned int    x_size;                                             // number of clusters in row
426    unsigned int    y_size;                     // number of clusters in a column
427    unsigned int    nprocs;                     // number of processors per cluster
428    giet_procs_number( &x_size, &y_size, &nprocs );
429
430    // get processor identifiers
431    unsigned int    x;
432    unsigned int    y;
433    unsigned int    l;
434    giet_proc_xyp( &x, &y, &l );
435
436    if ( (x==0) && (y==0) )
437    {
438        giet_shr_printf("\n*** Task analyse on P[%d][%d][%d] starts at cycle %d\n"
439                        "  x_size = %d / y_size = %d / nprocs = %d\n",
440                        x , y , l , giet_proctime() , x_size, y_size, nprocs );
441    }
442
443    // all "analyse" tasks wait heaps and mwmr channels initialisation
444    while ( local_sync[x][y] == 0 ) asm volatile ("nop");
445
446    // all "analyse" tasks register pointers on working containers in local stack
447    unsigned int   n;
448    unsigned int   analysis_tasks = nprocs-2;
449    unsigned int*  cont[NPROCS_MAX-2]; 
450    for ( n = 0 ; n < analysis_tasks ; n++ )
451    {
452        cont[n] = container[x][y][n];
453    }
454
455    // all "analyse" tasks register pointers on mwmr fifos in local stack
456    mwmr_channel_t* fifo_l2a = mwmr_l2a[x][y];
457    mwmr_channel_t* fifo_a2s = mwmr_a2s[x][y];
458
459    // "analyse" task[0][0] display status
460    if ( (x==0) && (y==0) )
461    giet_shr_printf("\n*** Task analyse on P[%d,%d,%d] enters main loop at cycle %d\n"
462                    "       &mwmr_l2a = %x\n"
463                    "       &mwmr_a2s = %x\n"
464                    "       &cont[0]  = %x\n",
465                    x, y, l, giet_proctime(), 
466                    (unsigned int)fifo_l2a,
467                    (unsigned int)fifo_a2s,
468                    (unsigned int)cont[0] );
469     
470    /////////////////////////////////////////////////////////////
471    // all "analyse" tasks enter the main loop (on containers)
472    unsigned int  index;           // available container index
473    unsigned int* temp;            // pointer on available container
474    unsigned int  nwords;          // number of words in container
475    unsigned int  npackets;        // number of packets in container
476    unsigned int  length;          // number of bytes in current packet
477    unsigned int  first;           // current packet first word in container
478    unsigned int  type;            // current packet type
479    unsigned int  p;               // current packet index
480
481#if VERBOSE_ANALYSE
482    unsigned int       verbose_len[10]; // save length for all packets in one container
483    unsigned long long verbose_dst[10]; // save length for all packets in one container
484    unsigned long long verbose_src[10]; // save length for all packets in one container
485#endif
486
487    while ( 1 )
488    { 
489
490#if VERBOSE_ANALYSE
491            for( p = 0 ; p < 10 ; p++ )
492            {
493                verbose_len[p] = 0;
494                verbose_dst[p] = 0;
495                verbose_src[p] = 0;
496            }
497#endif
498        // get one working container index from fifo_l2a
499        mwmr_read( fifo_l2a , &index , 1 );
500        temp = cont[index];
501
502        // get packets number and words number
503        npackets = temp[0] & 0x0000FFFF;
504        nwords   = temp[0] >> 16;
505
506        if ( (x==0) && (y==0) )
507        giet_shr_printf("\n*** Task analyse on P[%d,%d,%d] get container at cycle %d"
508                        " : %d packets / %d words\n",
509                                                x, y, l, giet_proctime(), npackets, nwords );
510
511        // initialize word index in container
512        first = 34;
513
514        // loop on packets
515        for( p = 0 ; p < npackets ; p++ )
516        {
517            // get packet length from container header
518            if ( (p & 0x1) == 0 )  length = temp[1+(p>>1)] >> 16;
519            else                   length = temp[1+(p>>1)] & 0x0000FFFF;
520
521            // compute packet DST and SRC MAC addresses
522            unsigned int word0 = temp[first];
523            unsigned int word1 = temp[first + 1];
524            unsigned int word2 = temp[first + 2];
525
526#if VERBOSE_ANALYSE
527            unsigned long long dst = ((unsigned long long)(word1 & 0xFFFF0000)>>16) |
528                                     (((unsigned long long)word0)<<16);
529            unsigned long long src = ((unsigned long long)(word1 & 0x0000FFFF)<<32) |
530                                     ((unsigned long long)word2);
531            if ( p < 10 )
532            {
533                verbose_len[p] = length;
534                verbose_dst[p] = dst;
535                verbose_src[p] = src;
536            }
537#endif
538            // compute type from SRC MAC address and increment counter
539            type = word1 & 0x0000000F;
540            atomic_increment( &counter[type], 1 );
541
542            // exchange SRC & DST MAC addresses for TX
543            temp[first]     = ((word1 & 0x0000FFFF)<<16) | ((word2 & 0xFFFF0000)>>16);
544            temp[first + 1] = ((word2 & 0x0000FFFF)<<16) | ((word0 & 0xFFFF0000)>>16);
545            temp[first + 2] = ((word0 & 0x0000FFFF)<<16) | ((word1 & 0xFFFF0000)>>16);
546
547            // update first word index
548            if ( length & 0x3 ) first += (length>>2)+1;
549            else                first += (length>>2);
550        }
551       
552#if VERBOSE_ANALYSE
553        if ( (x==0) && (y==0) )
554        giet_shr_printf("\n*** Task analyse on P[%d,%d,%d] completes at cycle %d\n"
555                        "   - Packet 0 : plen = %d / dst_mac = %l / src_mac = %l\n"
556                        "   - Packet 1 : plen = %d / dst_mac = %l / src_mac = %l\n"
557                        "   - Packet 2 : plen = %d / dst_mac = %l / src_mac = %l\n"
558                        "   - Packet 3 : plen = %d / dst_mac = %l / src_mac = %l\n"
559                        "   - Packet 4 : plen = %d / dst_mac = %l / src_mac = %l\n"
560                        "   - Packet 5 : plen = %d / dst_mac = %l / src_mac = %l\n"
561                        "   - Packet 6 : plen = %d / dst_mac = %l / src_mac = %l\n"
562                        "   - Packet 7 : plen = %d / dst_mac = %l / src_mac = %l\n"
563                        "   - Packet 8 : plen = %d / dst_mac = %l / src_mac = %l\n"
564                        "   - Packet 9 : plen = %d / dst_mac = %l / src_mac = %l\n",
565                        x , y , l , giet_proctime() , 
566                        verbose_len[0] , verbose_dst[0] , verbose_src[0] ,
567                        verbose_len[1] , verbose_dst[1] , verbose_src[1] ,
568                        verbose_len[2] , verbose_dst[2] , verbose_src[2] ,
569                        verbose_len[3] , verbose_dst[3] , verbose_src[3] ,
570                        verbose_len[4] , verbose_dst[4] , verbose_src[4] ,
571                        verbose_len[5] , verbose_dst[5] , verbose_src[5] ,
572                        verbose_len[6] , verbose_dst[6] , verbose_src[6] ,
573                        verbose_len[7] , verbose_dst[7] , verbose_src[7] ,
574                        verbose_len[8] , verbose_dst[8] , verbose_src[8] ,
575                        verbose_len[9] , verbose_dst[9] , verbose_src[9] );
576#endif
577           
578        // pseudo-random delay
579        for( p = 0 ; p < (giet_rand()>>4) ; p++ ) asm volatile ("nop");
580
581        // put the working container index to fifo_a2s
582        mwmr_write( fifo_a2s , &index , 1 );
583    }
584} // end analyse()
585
Note: See TracBrowser for help on using the repository browser.