Ignore:
Timestamp:
Aug 3, 2012, 12:30:44 PM (12 years ago)
Author:
meunier
Message:

soft_transpose update to match platform changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/softs/soft_transpose_giet/main.c

    r171 r244  
     1
    12#include "stdio.h"
    2 
    3 #define NL              512
    4 #define NP              512
    5 #define NB_IMAGES       1
    6 #define BLOCK_SIZE      512
    7 
    8 #define PRINTF          if(local_id == 0) tty_printf
     3#include "limits.h"
     4#include "../giet_tsar/block_device.h"
     5
     6#define NL              512
     7#define NP              512
     8#define NB_IMAGES       1
     9#define NB_CLUSTER_MAX  256
     10
     11#define PRINTF(...)      ({ if (local_id == 0) { tty_printf(__VA_ARGS__); } })
    912
    1013///////////////////////////////////////////
    … …  
    1417struct plaf;
    1518
     19extern struct plouf seg_ioc_base;
    1620extern struct plaf seg_heap_base;
    1721extern struct plaf NB_PROCS;
    … …  
    1923
    2024/////////////
    21 void main()
    22 {
    23     unsigned int        image     = 0;
    24     unsigned int        date      = 0;
    25 
    26     unsigned int        c;                                              // cluster index for loops
    27     unsigned int        l;                                              // line index for loops
    28     unsigned int        p;                                              // pixel index for loops
    29 
    30     unsigned int        proc_id     = procid();                         // processor id
    31     unsigned int        nprocs      = (unsigned int)&NB_PROCS;          // number of processors per cluster
    32     unsigned int        nclusters   = (unsigned int)&NB_CLUSTERS;       // number of clusters
    33     unsigned int        local_id    = proc_id%nprocs;                   // local processor id
    34     unsigned int        cluster_id  = proc_id/nprocs;                   // cluster id
    35     unsigned int        base        = (unsigned int)&seg_heap_base;     // base address for shared buffers
    36     unsigned int        increment   = (0x80000000 / nclusters) * 2;     // cluster increment
    37     unsigned int        ntasks      = nclusters * nprocs;               // number of tasks
    38     unsigned int        nblocks     = (NP*NL) / BLOCK_SIZE;             // number of blocks per image
    39 
    40     PRINTF("\n *** Entering main at cycle %d ***\n\n", proctime());
    41 
    42     //  parameters checking
    43     if( (nprocs != 1) && (nprocs != 2) && (nprocs != 4) )
    44     {
    45         PRINTF("NB_PROCS must be 1, 2 or 4\n");
    46     }
    47     if( (nclusters !=  1) && (nclusters !=  2) && (nclusters !=  4) && (nclusters !=  8) &&
    48         (nclusters != 16) && (nclusters != 32) && (nclusters != 64) && (nclusters !=128) &&
    49         (nclusters != 256) )
    50     {
    51         PRINTF("NB_CLUSTERS must be a power of 1 between 1 and 256\n");
    52     }
    53     if( ntasks > 1024 )
    54     {
    55         PRINTF("NB_PROCS * NB_CLUSTERS cannot be larger than 1024\n");
    56     }
    57     if( proc_id >= ntasks )
    58     {
    59         PRINTF("processor id %d larger than NB_CLUSTERS*NB_PROCS\n", proc_id);
    60     }
    61 
    62     // Arrays of pointers on the shared, distributed buffers containing the images
    63     // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters)
    64     unsigned char*      A[256];
    65     unsigned char*      B[256];
    66    
    67     // Arrays of pointers on the instrumentation arrays
    68     // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters)
    69     // each pointer points on the base adress of an array of NPROCS unsigned int
    70     unsigned int*       LOAD_START[256];
    71     unsigned int*       LOAD_ENDED[256];
    72     unsigned int*       TRSP_START[256];
    73     unsigned int*       TRSP_ENDED[256];
    74     unsigned int*       DISP_START[256];
    75     unsigned int*       DISP_ENDED[256];
    76  
    77     // shared buffers address definition
    78     // from the seg_heap_base and increment depending on the cluster index
    79     // These arrays of pointers are identical and replicated in the stack of each task
    80     for( c=0 ; c<nclusters ; c++)
    81     {
    82         A[c]          = (unsigned char*)(base           + increment*c);
    83         B[c]          = (unsigned char*)(base + NL*NP   + increment*c);
    84         LOAD_START[c] = (unsigned int*) (base + 2*NL*NP + increment*c);
    85         LOAD_ENDED[c] = (unsigned int*) (base + 3*NL*NP + increment*c);
    86         TRSP_START[c] = (unsigned int*) (base + 4*NL*NP + increment*c);
    87         TRSP_ENDED[c] = (unsigned int*) (base + 5*NL*NP + increment*c);
    88         DISP_START[c] = (unsigned int*) (base + 6*NL*NP + increment*c);
    89         DISP_ENDED[c] = (unsigned int*) (base + 7*NL*NP + increment*c);
    90     }
    91 
    92     PRINTF("NB_CLUSTERS = %d\n", nclusters);
    93     PRINTF("NB_PROCS    = %d\n\n", nprocs);
    94 
    95     PRINTF("*** starting barrier init at cycle %d ***\n", proctime());
    96 
    97     //  barriers initialization
    98     barrier_init(0, ntasks);
    99     barrier_init(1, ntasks);
    100     barrier_init(2, ntasks);
    101 
    102     PRINTF("*** completing barrier init at cycle %d ***\n", proctime());
    103 
    104     // Main loop (on images)
    105     while(image < NB_IMAGES)
    106     {
    107         // pseudo parallel load from disk to A[c] buffer : nblocks/nclusters blocks
    108         // only task running on processor with (local_id == 0) does it
    109 
    110         if ( local_id == 0 )
    111         {
    112             int p;
    113 
    114             date = proctime();
    115             PRINTF("\n*** Starting load for image %d at cycle %d\n", image, date);
    116             for ( p=0 ; p<nprocs ; p++ ) LOAD_START[cluster_id][p] = date;
    117 
    118             if( ioc_read(image*nblocks + nblocks*cluster_id/nclusters , A[cluster_id], nblocks/nclusters) )
    119             {
    120                 tty_printf("echec ioc_read\n");
    121                 exit();
     25void main(){
     26   unsigned int frame = 0;
     27   unsigned int date  = 0;
     28
     29   unsigned int c; // cluster index for loops
     30   unsigned int l; // line index for loops
     31   unsigned int p; // pixel index for loops
     32
     33   unsigned int proc_id       = procid();                      // processor id
     34   unsigned int nlocal_procs  = (unsigned int) &NB_PROCS;      // number of processors per cluster
     35   unsigned int nclusters     = (unsigned int) &NB_CLUSTERS;   // number of clusters
     36   unsigned int local_id      = proc_id % nlocal_procs;        // local processor id
     37   unsigned int cluster_id    = proc_id / nlocal_procs;        // cluster id
     38   unsigned int base          = (unsigned int) &seg_heap_base; // base address for shared buffers
     39   unsigned int increment     = 0x80000000 / nclusters * 2;    // cluster increment
     40   unsigned int nglobal_procs = nclusters * nlocal_procs;      // number of tasks
     41   unsigned int npixels       = NP * NL;                       // number of pixel per frame
     42   
     43   unsigned int * ioc_address = (unsigned int *) &seg_ioc_base;
     44   unsigned int block_size    = ioc_address[BLOCK_DEVICE_BLOCK_SIZE];
     45   unsigned int nblocks       = npixels / block_size;   // number of blocks per frame
     46
     47   PRINTF("\n *** Entering main at cycle %d ***\n\n", proctime());
     48
     49   //  parameters checking
     50   if ((nlocal_procs != 1) && (nlocal_procs != 2) && (nlocal_procs != 4)){
     51      PRINTF("NB_PROCS must be 1, 2 or 4\n");
     52      exit(1);
     53   }
     54   if ((nclusters != 1) && (nclusters != 2) && (nclusters != 4) && (nclusters != 8) &&
     55         (nclusters != 16) && (nclusters != 32) && (nclusters != 64) && (nclusters != 128) &&
     56         (nclusters != 256)){
     57      PRINTF("NB_CLUSTERS must be a power of 1 between 1 and 256\n");
     58      exit(1);
     59   }
     60   if (nglobal_procs > 1024){
     61      PRINTF("NB_PROCS * NB_CLUSTERS cannot be larger than 1024\n");
     62      exit(1);
     63   }
     64   if (proc_id >= nglobal_procs){
     65      PRINTF("processor id %d larger than NB_CLUSTERS*NB_PROCS\n", proc_id);
     66      exit(1);
     67   }
     68
     69   // Arrays of pointers on the shared, distributed buffers containing the frames
     70   // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters)
     71   unsigned char * A[NB_CLUSTER_MAX];
     72   unsigned char * B[NB_CLUSTER_MAX];
     73
     74   // Arrays of pointers on the instrumentation arrays
     75   // These arrays are indexed by the cluster index (sized for the worst case : 256 clusters)
     76   // each pointer points on the base adress of an array of NPROCS unsigned int
     77   unsigned int * LOAD_START[NB_CLUSTER_MAX];
     78   unsigned int * LOAD_END[NB_CLUSTER_MAX];
     79   unsigned int * TRSP_START[NB_CLUSTER_MAX];
     80   unsigned int * TRSP_END[NB_CLUSTER_MAX];
     81   unsigned int * DISP_START[NB_CLUSTER_MAX];
     82   unsigned int * DISP_END[NB_CLUSTER_MAX];
     83
     84   // shared buffers address definition
     85   // from the seg_heap_base and increment depending on the cluster index
     86   // These arrays of pointers are identical and replicated in the stack of each task
     87   for (c = 0; c < nclusters; c++){
     88      A[c]          = (unsigned char *) (base                                  + increment * c);
     89      B[c]          = (unsigned char *) (base +     npixels                    + increment * c);
     90      LOAD_START[c] = (unsigned int *)  (base + 2 * npixels                    + increment * c);
     91      LOAD_END[c]   = (unsigned int *)  (base + 2 * npixels +     nlocal_procs + increment * c);
     92      TRSP_START[c] = (unsigned int *)  (base + 2 * npixels + 2 * nlocal_procs + increment * c);
     93      TRSP_END[c]   = (unsigned int *)  (base + 2 * npixels + 3 * nlocal_procs + increment * c);
     94      DISP_START[c] = (unsigned int *)  (base + 2 * npixels + 4 * nlocal_procs + increment * c);
     95      DISP_END[c]   = (unsigned int *)  (base + 2 * npixels + 5 * nlocal_procs + increment * c);
     96   }
     97
     98   PRINTF("NB_CLUSTERS     = %d\n", nclusters);
     99   PRINTF("NB_LOCAL_PROCS  = %d\n", nlocal_procs);
     100   PRINTF("NB_GLOBAL_PROCS = %d\n", nglobal_procs);
     101   PRINTF("NB_PIXELS       = %d\n", npixels);
     102   PRINTF("BLOCK_SIZE      = %d\n", block_size);
     103   PRINTF("NB_BLOCKS       = %d\n\n", nblocks);
     104
     105
     106   PRINTF("*** starting barrier init at cycle %d ***\n", proctime());
     107
     108   //  barriers initialization
     109   barrier_init(0, nglobal_procs);
     110   barrier_init(1, nglobal_procs);
     111   barrier_init(2, nglobal_procs);
     112
     113   PRINTF("*** completing barrier init at cycle %d ***\n", proctime());
     114
     115   // Main loop (on frames)
     116   while (frame < NB_IMAGES){
     117      // pseudo parallel load from disk to A[c] buffer : nblocks/nclusters blocks
     118      // only task running on processor with (local_id == 0) does it
     119
     120      if (local_id == 0){
     121         int p;
     122
     123         date = proctime();
     124         PRINTF("\n*** Starting load for frame %d at cycle %d\n", frame, date);
     125         
     126         for (p = 0; p < nlocal_procs; p++){
     127            LOAD_START[cluster_id][p] = date;
     128         }
     129         tty_printf("    block_device offset : %d\n", nblocks * cluster_id / nclusters);
     130         if (ioc_read(frame * nblocks + nblocks * cluster_id / nclusters, A[cluster_id], nblocks / nclusters)){
     131            tty_printf("echec ioc_read\n");
     132            exit();
     133         }
     134         if (ioc_completed()){
     135            tty_printf("echec ioc_completed\n");
     136            exit();
     137         }
     138
     139         date = proctime();
     140         PRINTF("*** Completing load for frame %d at cycle %d\n", frame, date);
     141         for (p = 0; p < nlocal_procs; p++){
     142            LOAD_END[cluster_id][p] = date;
     143         }
     144      }
     145
     146      barrier_wait(0);
     147
     148      // parallel transpose from A to B buffers
     149      // each processor makes the transposition for (NL/nglobal_procs) lines
     150      // (p,l) are the (x,y) pixel coordinates in the source frame
     151
     152      date = proctime();
     153      PRINTF("\n*** Starting transpose for frame %d at cycle %d\n", frame, date);
     154      TRSP_START[cluster_id][local_id] = date;
     155
     156      unsigned int nlt   = NL / nglobal_procs; // Nombre de ligne à traiter par processeur
     157      unsigned int first = proc_id * nlt;      // Index de la premiÚre ligne à traiter pour le proc courant (celui qui exécute le code)
     158      unsigned int last  = first + nlt;        // Index de la derniÚre ligne
     159      unsigned int nlines_clusters = NL / nclusters; // Nombre de lignes à traiter par cluster
     160      unsigned int npix_clusters   = NP / nclusters; // Nombre de pixels par ligne à traiter par cluster
     161
     162      for (l = first; l < last; l++){
     163         PRINTF("    - processing line %d\n", l);
     164         for (p = 0; p < NP; p++){
     165            unsigned int source_index   = (l % nlines_clusters) * NP + p;
     166            unsigned int dest_cluster   = p / npix_clusters;
     167            unsigned int dest_index     = (p % npix_clusters) * NL + l;
     168            B[dest_cluster][dest_index] = A[cluster_id][source_index];
     169         }
     170      }
     171
     172      date = proctime();
     173      PRINTF("*** Completing transpose for frame %d at cycle %d\n", frame, date);
     174      TRSP_END[cluster_id][local_id] = date;
     175
     176      barrier_wait(1);
     177
     178      // parallel display from B[c] to frame buffer
     179      // each processor uses its private dma to display NL*NP/nglobal_procs pixels
     180
     181      date = proctime();
     182      PRINTF("\n*** Starting display for frame %d at cycle %d\n", frame, date);
     183      DISP_START[cluster_id][local_id] = date;
     184
     185      unsigned int npxt = npixels / nglobal_procs;   // number of pixels per proc
     186      if (npixels - npxt * nglobal_procs != 0){
     187         tty_printf("*** Error line %d\n", __LINE__);
     188         exit();
     189      }
     190      tty_printf("    npxt : %d\n", npxt);
     191
     192      if (fb_write(npxt * proc_id, B[cluster_id] + npxt * local_id, npxt)){
     193         tty_printf("[%d]: echec fb_sync_write\n", proc_id);
     194         exit();
     195      }
     196     
     197      PRINTF("    After fb_write and before fb_completed\n");
     198
     199      if (fb_completed()){
     200         tty_printf("[%d]: echec fb_completed\n", proc_id);
     201         exit();
     202      }
     203
     204      date = proctime();
     205      PRINTF("*** Completing display for frame %d at cycle %d\n", frame, date);
     206      DISP_END[cluster_id][local_id] = date;
     207
     208      barrier_wait(2);
     209
     210      // Instrumentation (done by processor 0 in cluster 0)
     211      if (local_id == 0){
     212         date = proctime();
     213         PRINTF("\n*** Starting Instrumentation for frame %d at cycle %d\n\n", frame, date);
     214
     215         int cc, pp;
     216         unsigned int min_load_start = INT_MAX;
     217         unsigned int max_load_start = 0;
     218         unsigned int min_load_ended = INT_MAX;
     219         unsigned int max_load_ended = 0;
     220         unsigned int min_trsp_start = INT_MAX;
     221         unsigned int max_trsp_start = 0;
     222         unsigned int min_trsp_ended = INT_MAX;
     223         unsigned int max_trsp_ended = 0;
     224         unsigned int min_disp_start = INT_MAX;
     225         unsigned int max_disp_start = 0;
     226         unsigned int min_disp_ended = INT_MAX;
     227         unsigned int max_disp_ended = 0;
     228
     229         for (cc = 0; cc < nclusters; cc++){
     230            for (pp = 0; pp < nlocal_procs; pp++){
     231               if (LOAD_START[cc][pp] < min_load_start){
     232                  min_load_start = LOAD_START[cc][pp];
     233               }
     234               if (LOAD_START[cc][pp] > max_load_start){
     235                  max_load_start = LOAD_START[cc][pp];
     236               }
     237               if (LOAD_END[cc][pp] < min_load_ended){
     238                  min_load_ended = LOAD_END[cc][pp];
     239               }
     240               if (LOAD_END[cc][pp] > max_load_ended){
     241                  max_load_ended = LOAD_END[cc][pp];
     242               }
     243
     244               if (TRSP_START[cc][pp] < min_trsp_start){
     245                  min_trsp_start = TRSP_START[cc][pp];
     246               }
     247               if (TRSP_START[cc][pp] > max_trsp_start){
     248                  max_trsp_start = TRSP_START[cc][pp];
     249               }
     250               if (TRSP_END[cc][pp] < min_trsp_ended){
     251                  min_trsp_ended = TRSP_END[cc][pp];
     252               }
     253               if (TRSP_END[cc][pp] > max_trsp_ended){
     254                  max_trsp_ended = TRSP_END[cc][pp];
     255               }
     256
     257               if (DISP_START[cc][pp] < min_disp_start){
     258                  min_disp_start = DISP_START[cc][pp];
     259               }
     260               if (DISP_START[cc][pp] > max_disp_start){
     261                  max_disp_start = DISP_START[cc][pp];
     262               }
     263               if (DISP_END[cc][pp] < min_disp_ended){
     264                  min_disp_ended = DISP_END[cc][pp];
     265               }
     266               if (DISP_END[cc][pp] > max_disp_ended){
     267                  max_disp_ended = DISP_END[cc][pp];
     268               }
    122269            }
    123             if ( ioc_completed() )
    124             {
    125                 tty_printf("echec ioc_completed\n");
    126                 exit();
    127             }
    128 
    129             date = proctime();
    130             PRINTF("*** Completing load for image %d at cycle %d\n", image, date);
    131             for ( p=0 ; p<nprocs ; p++ ) LOAD_ENDED[cluster_id][p] = date;
    132         }
    133 
    134         barrier_wait(0);
    135 
    136         // parallel transpose from A to B buffers
    137         // each processor makes the transposition for (NL/ntasks) lines
    138         // (p,l) are the (x,y) pixel coordinates in the source image
    139 
    140 
    141         date = proctime();
    142         PRINTF("\n*** Starting transpose for image %d at cycle %d\n", image, date);
    143         TRSP_START[cluster_id][local_id] = date;
    144 
    145         unsigned int nlt        = NL/ntasks;
    146         unsigned int first      = (cluster_id*nprocs + local_id)*nlt;
    147         unsigned int last       = first + nlt;
    148 
    149         for ( l=first ; l<last ; l++)
    150         {
    151             PRINTF( "    - processing line %d\n", l);
    152             for ( p=0 ; p<NP ; p++)
    153             {
    154                 unsigned int source_cluster = l/(NL/nclusters);
    155                 unsigned int source_index   = (l%(NL/nclusters))*NP + p;
    156                 unsigned int dest_cluster   = p / (NP/nclusters);
    157                 unsigned int dest_index     = (p%(NP/nclusters))*NL + l;
    158                 B[dest_cluster][dest_index] = A[source_cluster][source_index];
    159             }
    160 
    161         }
    162         date = proctime();
    163         PRINTF("*** Completing transpose for image %d at cycle %d\n", image, date);
    164         TRSP_ENDED[cluster_id][local_id] = date;
    165 
    166         barrier_wait(1);
    167 
    168         // parallel display from B[c] to frame buffer
    169         // each processor uses its private dma to display NL*NP/ntasks pixels
    170 
    171         date = proctime();
    172         PRINTF("\n*** Starting display for image %d at cycle %d\n", image, date);
    173         DISP_START[cluster_id][local_id] = date;
    174 
    175         unsigned int npxt = NL*NP/ntasks;       // number of pixels per task
    176 
    177         if ( fb_write(npxt*proc_id, B[cluster_id] + npxt*local_id, npxt) )
    178         {
    179             PRINTF("echec fb_sync_write\n");
    180             exit();
    181         }
    182         if ( fb_completed() )
    183         {
    184             PRINTF("echec fb_completed\n");
    185             exit();
    186         }
    187 
    188         date = proctime();
    189         PRINTF("*** Completing display for image %d at cycle %d\n", image, date);
    190         DISP_ENDED[cluster_id][local_id] = date;
    191 
    192         barrier_wait(2);
    193 
    194         // Instrumentation (done by processor 0 in cluster 0)
    195         if ( local_id == 0 )
    196         {
    197             date = proctime();
    198             PRINTF("\n*** Starting Instrumentation for image %d at cycle %d\n\n", image, date);
    199 
    200             int cc, pp;
    201             unsigned int min_load_start = 1000000000;
    202             unsigned int max_load_start = 0;
    203             unsigned int min_load_ended = 1000000000;
    204             unsigned int max_load_ended = 0;
    205             unsigned int min_trsp_start = 1000000000;
    206             unsigned int max_trsp_start = 0;
    207             unsigned int min_trsp_ended = 1000000000;
    208             unsigned int max_trsp_ended = 0;
    209             unsigned int min_disp_start = 1000000000;
    210             unsigned int max_disp_start = 0;
    211             unsigned int min_disp_ended = 1000000000;
    212             unsigned int max_disp_ended = 0;
    213 
    214             for ( cc=0 ; cc<nclusters ; cc++ )
    215             {
    216                 for ( pp=0 ; pp<nprocs ; pp++ )
    217                 {
    218                     if ( LOAD_START[cc][pp] < min_load_start ) min_load_start = LOAD_START[cc][pp];
    219                     if ( LOAD_START[cc][pp] > max_load_start ) max_load_start = LOAD_START[cc][pp];
    220                     if ( LOAD_ENDED[cc][pp] < min_load_ended ) min_load_ended = LOAD_ENDED[cc][pp];
    221                     if ( LOAD_ENDED[cc][pp] > max_load_ended ) max_load_ended = LOAD_ENDED[cc][pp];
    222 
    223                     if ( TRSP_START[cc][pp] < min_trsp_start ) min_trsp_start = TRSP_START[cc][pp];
    224                     if ( TRSP_START[cc][pp] > max_trsp_start ) max_trsp_start = TRSP_START[cc][pp];
    225                     if ( TRSP_ENDED[cc][pp] < min_trsp_ended ) min_trsp_ended = TRSP_ENDED[cc][pp];
    226                     if ( TRSP_ENDED[cc][pp] > max_trsp_ended ) max_trsp_ended = TRSP_ENDED[cc][pp];
    227 
    228                     if ( DISP_START[cc][pp] < min_disp_start ) min_disp_start = DISP_START[cc][pp];
    229                     if ( DISP_START[cc][pp] > max_disp_start ) max_disp_start = DISP_START[cc][pp];
    230                     if ( DISP_ENDED[cc][pp] < min_disp_ended ) min_disp_ended = DISP_ENDED[cc][pp];
    231                     if ( DISP_ENDED[cc][pp] > max_disp_ended ) max_disp_ended = DISP_ENDED[cc][pp];
    232 
    233                 }
    234             }
    235             PRINTF(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n",
    236             min_load_start, max_load_start, (min_load_start+max_load_start)/2, max_load_start-min_load_start);
    237             PRINTF(" - LOAD_END   : min = %d / max = %d / med = %d / delta = %d\n",
    238             min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, max_load_ended-min_load_ended);
    239 
    240             PRINTF(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n",
    241             min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, max_trsp_start-min_trsp_start);
    242             PRINTF(" - TRSP_END   : min = %d / max = %d / med = %d / delta = %d\n",
    243             min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, max_trsp_ended-min_trsp_ended);
    244 
    245             PRINTF(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n",
    246             min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, max_disp_start-min_disp_start);
    247             PRINTF(" - DISP_END   : min = %d / max = %d / med = %d / delta = %d\n",
    248             min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, max_disp_ended-min_disp_ended);
    249 
    250             PRINTF(" - BARRIER TRSP/DISP = %d\n", min_disp_start - max_trsp_ended);
    251         }
    252         // next image
    253         image++;
    254 
    255     } // end while image     
    256 
    257     while(1);
     270         }
     271
     272         PRINTF(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n",
     273               min_load_start, max_load_start, (min_load_start+max_load_start)/2, max_load_start-min_load_start);
     274         PRINTF(" - LOAD_END   : min = %d / max = %d / med = %d / delta = %d\n",
     275               min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2, max_load_ended-min_load_ended);
     276
     277         PRINTF(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n",
     278               min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2, max_trsp_start-min_trsp_start);
     279         PRINTF(" - TRSP_END   : min = %d / max = %d / med = %d / delta = %d\n",
     280               min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2, max_trsp_ended-min_trsp_ended);
     281
     282         PRINTF(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n",
     283               min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2, max_disp_start-min_disp_start);
     284         PRINTF(" - DISP_END   : min = %d / max = %d / med = %d / delta = %d\n",
     285               min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2, max_disp_ended-min_disp_ended);
     286
     287         PRINTF(" - BARRIER TRSP/DISP = %d\n", min_disp_start - max_trsp_ended);
     288      }
     289      frame++;
     290
     291   } // end while frame     
     292
     293   PRINTF("*** End of main ***\n");
     294
     295   while(1);
    258296} // end main()
    259297
     298// Local Variables:
     299// tab-width: 3
     300// c-basic-offset: 3
     301// c-file-offsets:((innamespace . 0)(inline-open . 0))
     302// indent-tabs-mode: nil
     303// End:
     304
     305// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
     306
     307
     308
Note: See TracChangeset for help on using the changeset viewer.