source: soft/giet_vm/convol/main.c @ 384

Last change on this file since 384 was 384, checked in by alain, 10 years ago

Update the convol application to use the new malloc.h and barrier.h libraries.
File size: 24.8 KB
Line 
1////////////////////////////////////////////////////////////////////////////////////////////
2// File   : main.c   (for convol application)
3// Date   : june 2014
4// author : Alain Greiner
5//
6// The "convol" application implements a 2D convolution product. 
7////////////////////////////////////////////////////////////////////////////////////////////
8
9#include "hard_config.h"
10#include "stdio.h"
11#include "stdlib.h"
12#include "barrier.h"
13#include "malloc.h"
14
15#define USE_SBT_BARRIER            1
16#define VERBOSE                    0
17#define SUPER_VERBOSE              0
18
19#define INITIAL_DISPLAY_ENABLE     0
20#define FINAL_DISPLAY_ENABLE       1
21
22#define NB_CLUSTERS                (X_SIZE * Y_SIZE)
23#define PIXEL_SIZE                 2
24#define NL                         1024
25#define NP                         1024
26#define NB_PIXELS                  (NP * NL)
27#define FRAME_SIZE                 (NB_PIXELS * PIXEL_SIZE)
28
29#define TA(c,l,p)  (A[c][((NP) * (l)) + (p)])
30#define TB(c,p,l)  (B[c][((NL) * (p)) + (l)])
31#define TC(c,l,p)  (C[c][((NP) * (l)) + (p)])
32#define TD(c,l,p)  (D[c][((NP) * (l)) + (p)])
33#define TZ(c,l,p)  (Z[c][((NP) * (l)) + (p)])
34
35#define max(x,y) ((x) > (y) ? (x) : (y))
36#define min(x,y) ((x) < (y) ? (x) : (y))
37
38// global instrumentation counters (cluster_id, lpid]
39
40unsigned int START[NB_CLUSTERS][NB_PROCS_MAX];
41unsigned int H_BEG[NB_CLUSTERS][NB_PROCS_MAX];
42unsigned int H_END[NB_CLUSTERS][NB_PROCS_MAX];
43unsigned int V_BEG[NB_CLUSTERS][NB_PROCS_MAX];
44unsigned int V_END[NB_CLUSTERS][NB_PROCS_MAX];
45unsigned int D_BEG[NB_CLUSTERS][NB_PROCS_MAX];
46unsigned int D_END[NB_CLUSTERS][NB_PROCS_MAX];
47
48// global synchronization barrier
49
50#if USE_SBT_BARRIER
51giet_sbt_barrier_t  barrier;
52#else
53giet_barrier_t      barrier;
54#endif
55
56volatile unsigned int barrier_init_ok    = 0;
57volatile unsigned int load_image_ok      = 0;
58volatile unsigned int instrumentation_ok = 0;
59
60// global pointers on distributed buffers in all clusters
61unsigned short * GA[NB_CLUSTERS];
62int *            GB[NB_CLUSTERS];
63int *            GC[NB_CLUSTERS];
64int *            GD[NB_CLUSTERS];
65unsigned char *  GZ[NB_CLUSTERS];
66
67///////////////////////////////////////////
68__attribute__ ((constructor)) void main()
69///////////////////////////////////////////
70{
71    //////////////////////////////////
72    // convolution kernel parameters
73    // The content of this section is
74    // Philips proprietary information.
75    ///////////////////////////////////
76
77    int   vnorm  = 115;
78    int   vf[35] = { 1, 1, 2, 2, 2,
79                     2, 3, 3, 3, 4,
80                     4, 4, 4, 5, 5,
81                     5, 5, 5, 5, 5,
82                     5, 5, 4, 4, 4,
83                     4, 3, 3, 3, 2,
84                     2, 2, 2, 1, 1 };
85
86    int hrange = 100;
87    int hnorm  = 201;
88
89    unsigned int date = 0;
90
91    int c; // cluster index for loops
92    int l; // line index for loops
93    int p; // pixel index for loops
94    int z; // vertical filter index for loops
95
96    int          file        = 0;                             // file descriptor
97    unsigned int pid         = giet_procid();                 // processor id
98    unsigned int nprocs      = NB_PROCS_MAX;                  // procs per cluster
99    unsigned int nclusters   = NB_CLUSTERS;                   // number of clusters
100    unsigned int lpid        = pid % nprocs;                  // local task id
101    unsigned int cluster_xy  = pid / nprocs;                  // cluster index
102    unsigned int x           = cluster_xy >> Y_WIDTH;         // x coordinate
103    unsigned int y           = cluster_xy & ((1<<Y_WIDTH)-1); // y coordinate
104    unsigned int cluster_id  = (x * Y_SIZE) + y;              // continuous cluster index
105    unsigned int task_id     = (cluster_id * nprocs) + lpid;  // continuous task index
106    unsigned int ntasks      = nclusters * nprocs;            // number of tasks
107    unsigned int npixels     = NB_PIXELS;                     // pixels per frame
108    unsigned int frame_size  = FRAME_SIZE;                    // total size (bytes)
109    unsigned int nblocks     = frame_size / 512;              // number of blocks per frame
110
111    unsigned int lines_per_task     = NL / ntasks;            // lines per task
112    unsigned int lines_per_cluster  = NL / nclusters;         // lines per cluster
113    unsigned int pixels_per_task    = NP / ntasks;            // columns per task
114    unsigned int pixels_per_cluster = NP / nclusters;         // columns per cluster
115
116    int first, last;
117
118    date = giet_proctime();
119    START[cluster_id][lpid] = date;
120
121#if VERBOSE
122giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts at cycle %d\n", x,y,lpid, date );
123#endif
124
125     // parameters checking
126   
127    if ((nprocs != 1) && (nprocs != 2) && (nprocs != 4))
128        giet_exit( "[CONVOL ERROR] NB_PROCS_MAX must be 1, 2 or 4\n");
129
130    if ((X_SIZE!=1) && (X_SIZE!=2) && (X_SIZE!=4) && (X_SIZE!=8))
131        giet_exit( "[CONVOL ERROR] X_SIZE must be 1, 2, 4, 8\n");
132       
133    if ((Y_SIZE!=1) && (Y_SIZE!=2) && (Y_SIZE!=4) && (Y_SIZE!=8))
134        giet_exit( "[CONVOL ERROR] X_SIZE must be 1, 2, 4, 8\n");
135
136    if ( NL % nclusters != 0 )
137        giet_exit( "[CONVOL ERROR] NB_CLUSTERS must be a divider of NL");
138
139    if ( NP % nclusters != 0 )
140        giet_exit( "[CONVOL ERROR] NB_CLUSTERS must be a divider of NP");
141
142   
143    ///////////////////////////////////////////////////////////////////
144    // task[0][0][0] makes barrier initialisation
145    ///////////////////////////////////////////////////////////////////
146   
147    if ( pid == 0 )
148    {
149        giet_shr_printf("\n[CONVOL] task[0,0,0] starts barrier init at cycle %d\n" 
150                        "- NB_CLUSTERS     = %d\n"
151                        "- NB_LOCAL_PROCS  = %d\n" 
152                        "- NB_TASKS        = %d\n" 
153                        "- NB_PIXELS       = %x\n"           
154                        "- FRAME_SIZE      = %x\n"             
155                        "- NB_BLOCKS       = %x\n",
156                        giet_proctime(), nclusters, nprocs, ntasks, 
157                        npixels, frame_size, nblocks );
158#if USE_SBT_BARRIER
159        sbt_barrier_init( &barrier, ntasks );
160#else
161        barrier_init( &barrier, ntasks );
162#endif
163
164        giet_shr_printf( "\n[CONVOL] task[0,0,0] completes barrier init at cycle %d\n",
165                         giet_proctime() );
166
167        barrier_init_ok = 1;
168    }
169    else 
170    {
171        while ( barrier_init_ok == 0 );
172    }
173
174    ///////////////////////////////////////////////////////////////////
175    // All task[x][y][0] allocate the global buffers in cluster(x,y)
176    // These buffers mut be sector-aligned.
177    ///////////////////////////////////////////////////////////////////
178    if ( lpid == 0 )
179    {
180
181#if VERBOSE
182giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] enters malloc at cycle %d\n", x,y,lpid, date );
183#endif
184
185        GA[cluster_id] = remote_malloc( (FRAME_SIZE/nclusters)   , x , y );
186        GB[cluster_id] = remote_malloc( (FRAME_SIZE/nclusters)*2 , x , y );
187        GC[cluster_id] = remote_malloc( (FRAME_SIZE/nclusters)*2 , x , y );
188        GD[cluster_id] = remote_malloc( (FRAME_SIZE/nclusters)*2 , x , y );
189        GZ[cluster_id] = remote_malloc( (FRAME_SIZE/nclusters)/2 , x , y );
190       
191#if VERBOSE
192giet_shr_printf( "\n[CONVOL]  Shared Buffer Virtual Addresses in cluster(%d,%d)\n"
193                 "### GA = %x\n"
194                 "### GB = %x\n"               
195                 "### GC = %x\n"               
196                 "### GD = %x\n"               
197                 "### GZ = %x\n",
198                 x, y,
199                 GA[cluster_id],
200                 GB[cluster_id],
201                 GC[cluster_id],
202                 GD[cluster_id],
203                 GZ[cluster_id] );
204#endif
205    }
206
207    ///////////////////////////////
208    #if USE_SBT_BARRIER
209    sbt_barrier_wait( &barrier );
210    #else
211    barrier_wait( &barrier );
212    #endif
213
214    ///////////////////////////////////////////////////////////////////
215    // All tasks initialise in their private stack a copy of the
216    // arrays of pointers on the shared, distributed buffers.
217    ///////////////////////////////////////////////////////////////////
218
219    unsigned short * A[NB_CLUSTERS];
220    int *            B[NB_CLUSTERS];
221    int *            C[NB_CLUSTERS];
222    int *            D[NB_CLUSTERS];
223    unsigned char *  Z[NB_CLUSTERS];
224
225    for (c = 0; c < nclusters; c++)
226    {
227        A[c] = GA[c];
228        B[c] = GB[c];
229        C[c] = GC[c];
230        D[c] = GD[c];
231        Z[c] = GZ[c];
232    }
233
234    ///////////////////////////////////////////////////////////////////////////
235    // task[0,0,0] open the file containing image, and load it from disk
236    // to all A[c] buffers (nblocks / nclusters loaded in each cluster).
237    // Other tasks are waiting on the init_ok condition.
238    //////////////////////////////////////////////////////////////////////////
239    if ( pid == 0 )
240    {
241        // open file
242        file = giet_fat_open("misc/philips_image.raw", 0 );
243        if ( file < 0 ) giet_exit( "[CONVOL ERROR] task[0,0,0] cannot open"
244                                   " file misc/philips_image.raw" );
245 
246        giet_shr_printf( "\n[CONVOL] task[0,0,0] open file misc/philips_image.raw"
247                         " at cycle %d\n", giet_proctime() );
248
249        for ( c = 0 ; c < NB_CLUSTERS ; c++ )
250        {
251            giet_shr_printf( "\n[CONVOL] task[0,0,0] starts load "
252                             "for cluster %d at cycle %d\n", c, giet_proctime() );
253
254            giet_fat_read( file,
255                           A[c],
256                           nblocks/nclusters,
257                           (nblocks/nclusters)*c );
258
259            giet_shr_printf( "\n[CONVOL] task[0,0,0] completes load "
260                             "for cluster %d at cycle %d\n", c, giet_proctime() );
261        }
262        load_image_ok = 1;
263    }
264    else
265    {
266        while ( load_image_ok == 0 );
267    }
268
269    /////////////////////////////////////////////////////////////////////////////
270    // Optionnal parallel display of the initial image stored in A[c] buffers.
271    // Eah task displays (NL/ntasks) lines. (one byte per pixel).
272    /////////////////////////////////////////////////////////////////////////////
273
274    if ( INITIAL_DISPLAY_ENABLE )
275    {
276
277#if VERBOSE
278giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts initial display"
279                 " at cycle %d\n",
280                 x, y, lpid, giet_proctime() );
281#endif
282
283        unsigned int line;
284        unsigned int offset = lines_per_task * lpid;
285
286        for ( l = 0 ; l < lines_per_task ; l++ )
287        {
288            line = offset + l;
289
290            for ( p = 0 ; p < NP ; p++ )
291            {
292                TZ(cluster_id, line, p) = (unsigned char)(TA(cluster_id, line, p) >> 8);
293            }
294
295            giet_fb_sync_write( NP*(l + (task_id * lines_per_task) ), 
296                                &TZ(cluster_id, line, 0), 
297                                NP);
298        }
299
300#if VERBOSE
301giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes initial display"
302                 " at cycle %d\n",
303                 x, y, lpid, giet_proctime() );
304#endif
305
306        ////////////////////////////
307        #if USE_SBT_BARRIER
308        sbt_barrier_wait( &barrier );
309        #else
310        barrier_wait( &barrier );
311        #endif
312
313    }
314
315    ////////////////////////////////////////////////////////
316    // parallel horizontal filter :
317    // B <= transpose(FH(A))
318    // D <= A - FH(A)
319    // Each task computes (NL/ntasks) lines
320    // The image must be extended :
321    // if (z<0)    TA(cluster_id,l,z) == TA(cluster_id,l,0)
322    // if (z>NP-1) TA(cluster_id,l,z) == TA(cluster_id,l,NP-1)
323    ////////////////////////////////////////////////////////
324
325    date  = giet_proctime();
326    H_BEG[cluster_id][lpid] = date;
327
328#if VERBOSE
329giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts horizontal filter"
330                 " at cycle %d\n",
331                 x, y, lpid, date );
332#else
333if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] starts horizontal filter"
334                                 " at cycle %d\n", date );
335#endif
336
337    // l = absolute line index / p = absolute pixel index 
338    // first & last define which lines are handled by a given task
339
340    first = task_id * lines_per_task;
341    last  = first + lines_per_task;
342
343    for (l = first; l < last; l++)
344    {
345        // src_c and src_l are the cluster index and the line index for A & D
346        int src_c = l / lines_per_cluster;
347        int src_l = l % lines_per_cluster;
348
349        // We use the specific values of the horizontal ep-filter for optimisation:
350        // sum(p) = sum(p-1) + TA[p+hrange] - TA[p-hrange-1]
351        // To minimize the number of tests, the loop on pixels is split in three domains
352
353        int sum_p = (hrange + 2) * TA(src_c, src_l, 0);
354        for (z = 1; z < hrange; z++)
355        {
356            sum_p = sum_p + TA(src_c, src_l, z);
357        }
358
359        // first domain : from 0 to hrange
360        for (p = 0; p < hrange + 1; p++)
361        {
362            // dst_c and dst_p are the cluster index and the pixel index for B
363            int dst_c = p / pixels_per_cluster;
364            int dst_p = p % pixels_per_cluster;
365            sum_p = sum_p + (int) TA(src_c, src_l, p + hrange) - (int) TA(src_c, src_l, 0);
366            TB(dst_c, dst_p, l) = sum_p / hnorm;
367            TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm;
368        }
369        // second domain : from (hrange+1) to (NP-hrange-1)
370        for (p = hrange + 1; p < NP - hrange; p++)
371        {
372            // dst_c and dst_p are the cluster index and the pixel index for B
373            int dst_c = p / pixels_per_cluster;
374            int dst_p = p % pixels_per_cluster;
375            sum_p = sum_p + (int) TA(src_c, src_l, p + hrange) 
376                          - (int) TA(src_c, src_l, p - hrange - 1);
377            TB(dst_c, dst_p, l) = sum_p / hnorm;
378            TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm;
379        }
380        // third domain : from (NP-hrange) to (NP-1)
381        for (p = NP - hrange; p < NP; p++)
382        {
383            // dst_c and dst_p are the cluster index and the pixel index for B
384            int dst_c = p / pixels_per_cluster;
385            int dst_p = p % pixels_per_cluster;
386            sum_p = sum_p + (int) TA(src_c, src_l, NP - 1) 
387                          - (int) TA(src_c, src_l, p - hrange - 1);
388            TB(dst_c, dst_p, l) = sum_p / hnorm;
389            TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm;
390        }
391
392#if SUPER_VERBOSE
393giet_shr_printf(" - line %d computed at cycle %d\n", l, giet_proctime() );
394#endif   
395
396    }
397
398    date  = giet_proctime();
399    H_END[cluster_id][lpid] = date;
400
401#if VERBOSE
402giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes horizontal filter"
403                 " at cycle %d\n",
404                 x, y, lpid, date );
405#else
406if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] completes horizontal filter"
407                                 " at cycle %d\n", date );
408#endif
409
410    /////////////////////////////
411    #if USE_SBT_BARRIER
412    sbt_barrier_wait( &barrier );
413    #else
414    barrier_wait( &barrier );
415    #endif
416
417
418    ///////////////////////////////////////////////////////////////
419    // parallel vertical filter :
420    // C <= transpose(FV(B))
421    // Each task computes (NP/ntasks) columns
422    // The image must be extended :
423    // if (l<0)    TB(cluster_id,p,l) == TB(cluster_id,p,0)
424    // if (l>NL-1)   TB(cluster_id,p,l) == TB(cluster_id,p,NL-1)
425    ///////////////////////////////////////////////////////////////
426
427    date  = giet_proctime();
428    V_BEG[cluster_id][lpid] = date;
429
430#if VERBOSE
431giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts vertical filter"
432                 " at cycle %d\n",
433                 x, y, lpid, date );
434#else
435if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] starts vertical filter"
436                                 " at cycle %d\n", date );
437#endif
438
439    // l = absolute line index / p = absolute pixel index
440    // first & last define which pixels are handled by a given task
441
442    first = task_id * pixels_per_task;
443    last  = first + pixels_per_task;
444
445    for (p = first; p < last; p++)
446    {
447        // src_c and src_p are the cluster index and the pixel index for B
448        int src_c = p / pixels_per_cluster;
449        int src_p = p % pixels_per_cluster;
450
451        int sum_l;
452
453        // We use the specific values of the vertical ep-filter
454        // To minimize the number of tests, the NL lines are split in three domains
455
456        // first domain : explicit computation for the first 18 values
457        for (l = 0; l < 18; l++)
458        {
459            // dst_c and dst_l are the cluster index and the line index for C
460            int dst_c = l / lines_per_cluster;
461            int dst_l = l % lines_per_cluster;
462
463            for (z = 0, sum_l = 0; z < 35; z++)
464            {
465                sum_l = sum_l + vf[z] * TB(src_c, src_p, max(l - 17 + z,0) );
466            }
467            TC(dst_c, dst_l, p) = sum_l / vnorm;
468        }
469        // second domain
470        for (l = 18; l < NL - 17; l++)
471        {
472            // dst_c and dst_l are the cluster index and the line index for C
473            int dst_c = l / lines_per_cluster;
474            int dst_l = l % lines_per_cluster;
475
476            sum_l = sum_l + TB(src_c, src_p, l + 4)
477                  + TB(src_c, src_p, l + 8)
478                  + TB(src_c, src_p, l + 11)
479                  + TB(src_c, src_p, l + 15)
480                  + TB(src_c, src_p, l + 17)
481                  - TB(src_c, src_p, l - 5)
482                  - TB(src_c, src_p, l - 9)
483                  - TB(src_c, src_p, l - 12)
484                  - TB(src_c, src_p, l - 16)
485                  - TB(src_c, src_p, l - 18);
486
487            TC(dst_c, dst_l, p) = sum_l / vnorm;
488        }
489        // third domain
490        for (l = NL - 17; l < NL; l++)
491        {
492            // dst_c and dst_l are the cluster index and the line index for C
493            int dst_c = l / lines_per_cluster;
494            int dst_l = l % lines_per_cluster;
495
496            sum_l = sum_l + TB(src_c, src_p, min(l + 4, NL - 1))
497                  + TB(src_c, src_p, min(l + 8, NL - 1))
498                  + TB(src_c, src_p, min(l + 11, NL - 1))
499                  + TB(src_c, src_p, min(l + 15, NL - 1))
500                  + TB(src_c, src_p, min(l + 17, NL - 1))
501                  - TB(src_c, src_p, l - 5)
502                  - TB(src_c, src_p, l - 9)
503                  - TB(src_c, src_p, l - 12)
504                  - TB(src_c, src_p, l - 16)
505                  - TB(src_c, src_p, l - 18);
506
507            TC(dst_c, dst_l, p) = sum_l / vnorm;
508        }
509
510#if SUPER_VERBOSE
511giet_shr_printf(" - column %d computed at cycle %d\n", p, giet_proctime());
512#endif
513
514    }
515
516    date  = giet_proctime();
517    V_END[cluster_id][lpid] = date;
518
519#if VERBOSE
520giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes vertical filter"
521                 " at cycle %d\n",
522                 x, y, lpid, date );
523#else
524if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] completes vertical filter"
525                                 " at cycle %d\n", date );
526#endif
527
528    ////////////////////////////
529    #if USE_SBT_BARRIER
530    sbt_barrier_wait( &barrier );
531    #else
532    barrier_wait( &barrier );
533    #endif
534
535    ////////////////////////////////////////////////////////////////
536    // Optional parallel display of the final image Z <= D + C
537    // Eah task displays (NL/ntasks) lines. (one byte per pixel).
538    ////////////////////////////////////////////////////////////////
539
540    if ( FINAL_DISPLAY_ENABLE )
541    {
542        date  = giet_proctime();
543        D_BEG[cluster_id][lpid] = date;
544
545#if VERBOSE
546giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] starts final display"
547                 " at cycle %d\n",
548                 x, y, lpid, date);
549#else
550if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] starts final display"
551                                 " at cycle %d\n", date );
552#endif
553
554        unsigned int line;
555        unsigned int offset = lines_per_task * lpid;
556
557        for ( l = 0 ; l < lines_per_task ; l++ )
558        {
559            line = offset + l;
560
561            for ( p = 0 ; p < NP ; p++ )
562            {
563                TZ(cluster_id, line, p) = 
564                   (unsigned char)( (TD(cluster_id, line, p) + 
565                                     TC(cluster_id, line, p) ) >> 8 );
566            }
567
568            giet_fb_sync_write( NP*(l + (task_id * lines_per_task) ), 
569                                &TZ(cluster_id, line, 0), 
570                                NP);
571        }
572
573        date  = giet_proctime();
574        D_END[cluster_id][lpid] = date;
575
576#if VERBOSE
577giet_shr_printf( "\n[CONVOL] task[%d,%d,%d] completes final display"
578                 " at cycle %d\n",
579                 x, y, lpid, date);
580#else
581if ( pid == 0 ) giet_shr_printf( "\n[CONVOL] task[0,0,0] completes final display"
582                                 " at cycle %d\n", date );
583#endif
584     
585    //////////////////////////////
586    #if USE_SBT_BARRIER
587    sbt_barrier_wait( &barrier );
588    #else
589    barrier_wait( &barrier );
590    #endif
591
592    }
593
594    /////////////////////////////////////////////////////////
595    // Task[0,0,0] makes the instrumentation
596    /////////////////////////////////////////////////////////
597
598    if ( pid == 0 )
599    {
600        date  = giet_proctime();
601        giet_shr_printf("\n[CONVOL] task[0,0,0] starts instrumentation"
602                        " at cycle %d\n\n", date );
603
604        int cc, pp;
605
606        unsigned int min_start = 0xFFFFFFFF;
607        unsigned int max_start = 0;
608
609        unsigned int min_h_beg = 0xFFFFFFFF;
610        unsigned int max_h_beg = 0;
611
612        unsigned int min_h_end = 0xFFFFFFFF;
613        unsigned int max_h_end = 0;
614
615        unsigned int min_v_beg = 0xFFFFFFFF;
616        unsigned int max_v_beg = 0;
617
618        unsigned int min_v_end = 0xFFFFFFFF;
619        unsigned int max_v_end = 0;
620
621        unsigned int min_d_beg = 0xFFFFFFFF;
622        unsigned int max_d_beg = 0;
623
624        unsigned int min_d_end = 0xFFFFFFFF;
625        unsigned int max_d_end = 0;
626
627        for (cc = 0; cc < nclusters; cc++)
628        {
629            for (pp = 0; pp < nprocs; pp++ )
630            {
631                if (START[cc][pp] < min_start) min_start = START[cc][pp];
632                if (START[cc][pp] > max_start) max_start = START[cc][pp];
633
634                if (H_BEG[cc][pp] < min_h_beg) min_h_beg = H_BEG[cc][pp];
635                if (H_BEG[cc][pp] > max_h_beg) max_h_beg = H_BEG[cc][pp];
636
637                if (H_END[cc][pp] < min_h_end) min_h_end = H_END[cc][pp];
638                if (H_END[cc][pp] > max_h_end) max_h_end = H_END[cc][pp];
639
640                if (V_BEG[cc][pp] < min_v_beg) min_v_beg = V_BEG[cc][pp];
641                if (V_BEG[cc][pp] > max_v_beg) max_v_beg = V_BEG[cc][pp];
642
643                if (V_END[cc][pp] < min_v_end) min_v_end = V_END[cc][pp];
644                if (V_END[cc][pp] > max_v_end) max_v_end = V_END[cc][pp];
645
646                if (D_BEG[cc][pp] < min_d_beg) min_d_beg = D_BEG[cc][pp];
647                if (D_BEG[cc][pp] > max_d_beg) max_d_beg = D_BEG[cc][pp];
648
649                if (D_END[cc][pp] < min_d_end) min_d_end = D_END[cc][pp];
650                if (D_END[cc][pp] > max_d_end) max_d_end = D_END[cc][pp];
651            }
652        }
653
654        giet_shr_printf(" - START : min = %d / max = %d / med = %d / delta = %d\n",
655               min_start, max_start, (min_start+max_start)/2, max_start-min_start);
656
657        giet_shr_printf(" - H_BEG : min = %d / max = %d / med = %d / delta = %d\n",
658               min_h_beg, max_h_beg, (min_h_beg+max_h_beg)/2, max_h_beg-min_h_beg);
659
660        giet_shr_printf(" - H_END : min = %d / max = %d / med = %d / delta = %d\n",
661               min_h_end, max_h_end, (min_h_end+max_h_end)/2, max_h_end-min_h_end);
662
663        giet_shr_printf(" - V_BEG : min = %d / max = %d / med = %d / delta = %d\n",
664               min_v_beg, max_v_beg, (min_v_beg+max_v_beg)/2, max_v_beg-min_v_beg);
665
666        giet_shr_printf(" - V_END : min = %d / max = %d / med = %d / delta = %d\n",
667               min_v_end, max_v_end, (min_v_end+max_v_end)/2, max_v_end-min_v_end);
668
669        giet_shr_printf(" - D_BEG : min = %d / max = %d / med = %d / delta = %d\n",
670               min_d_beg, max_d_beg, (min_d_beg+max_d_beg)/2, max_d_beg-min_d_beg);
671
672        giet_shr_printf(" - D_END : min = %d / max = %d / med = %d / delta = %d\n",
673               min_d_end, max_d_end, (min_d_end+max_d_end)/2, max_d_end-min_d_end);
674
675        giet_shr_printf( "\n General Scenario (Kcycles for each step)\n" );
676        giet_shr_printf( " - BOOT OS           = %d\n", (min_start            )/1000 );
677        giet_shr_printf( " - LOAD IMAGE        = %d\n", (min_h_beg - min_start)/1000 );
678        giet_shr_printf( " - H_FILTER          = %d\n", (max_h_end - min_h_beg)/1000 );
679        giet_shr_printf( " - BARRIER HORI/VERT = %d\n", (min_v_beg - max_h_end)/1000 );
680        giet_shr_printf( " - V_FILTER          = %d\n", (max_v_end - min_v_beg)/1000 );
681        giet_shr_printf( " - BARRIER VERT/DISP = %d\n", (min_d_beg - max_v_end)/1000 );
682        giet_shr_printf( " - DISPLAY           = %d\n", (max_d_end - min_d_beg)/1000 );
683
684        instrumentation_ok = 1;
685    }
686    else
687    {
688        while ( instrumentation_ok == 0 );
689    }
690
691    giet_exit( "completed");
692
693} // end main()
694
695// Local Variables:
696// tab-width: 3
697// c-basic-offset: 3
698// c-file-offsets:((innamespace . 0)(inline-open . 0))
699// indent-tabs-mode: nil
700// End:
701
702// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
703
704
Note: See TracBrowser for help on using the repository browser.