Changeset 736

Timestamp:

Dec 3, 2015, 4:40:49 PM (9 years ago)

Author:

alain

Message:

Modify the mjpeg application to support an optional
DCT hardware coprocessor.

Location:

soft/giet_vm/applications

Files:

• coproc/coproc.c (modified) (7 diffs)
• coproc/coproc.py (modified) (2 diffs)
• mjpeg/demux.c (modified) (14 diffs)
• mjpeg/idct.c (modified) (4 diffs)
• mjpeg/iqzz.c (modified) (5 diffs)
• mjpeg/libu.c (modified) (4 diffs)
• mjpeg/mjpeg.c (modified) (6 diffs)
• mjpeg/mjpeg.h (modified) (4 diffs)
• mjpeg/mjpeg.py (modified) (11 diffs)
• mjpeg/tg.c (modified) (1 diff)
• mjpeg/vld.c (modified) (13 diffs)

soft/giet_vm/applications/coproc/coproc.c

@@ -1 @@
-///////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
 //  file   : coproc.c
 //  date   : avril 2015
 //  author : Alain Greiner
-///////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
 //  This file describes the single thread "coproc" application.
 //  It uses the GCD (Greater Common Divider) hardware coprocessor
 //  to make the GCD computation between two vectors of 32 bits integers.
+//  It supports two coprocessor operating modes: MODE_DMA_IRQ or MODE_DMA_NO_IRQ. 
 //  The vectors size is defined by the VECTOR_SIZE parameter.
-///////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
 
 
@@ -41 +42 @@
                     x, y, lpid, giet_proctime() );
 
+    // check coprocessor operating mode
+    giet_pthread_assert( (DMA_MODE == MODE_DMA_IRQ) || (DMA_MODE == MODE_DMA_NO_IRQ),
+    "\n[COPROC ERROR] only MODE_DMA_IRQ and MODE_DMA_NO_IRQ modes are supported");
+
     // initializes opa & opb buffers
     unsigned int word;
@@ -50 +55 @@
 
     unsigned int coproc_info;
+    unsigned int cluster_xy  = (x << 4) + y;
+    unsigned int coproc_type = MWR_SUBTYPE_GCD;
 
-    /////////////////////// request a GCD coprocessor
-    giet_coproc_alloc( MWR_SUBTYPE_GCD, &coproc_info );
+    // get a GCD coprocessor in local cluster
+    giet_coproc_alloc( cluster_xy,
+                       coproc_type,
+                       &coproc_info );
 
     // check coprocessor ports
@@ -69 +78 @@
 #endif
 
-    //////////////////////// initializes channel for OPA
+    // initializes OPA channel
     giet_coproc_channel_t opa_desc;
     opa_desc.channel_mode = DMA_MODE;
     opa_desc.buffer_size  = VECTOR_SIZE<<2;
     opa_desc.buffer_vaddr = (unsigned int)opa;
-    giet_coproc_channel_init( 0 , &opa_desc );
+    giet_coproc_channel_init( cluster_xy,
+                              coproc_type,
+                              0, 
+                              &opa_desc );
     
-    //////////////////////// initializes channel for OPB
+    // initializes OPB channel
     giet_coproc_channel_t opb_desc;
     opb_desc.channel_mode = DMA_MODE;
     opb_desc.buffer_size  = VECTOR_SIZE<<2;
     opb_desc.buffer_vaddr = (unsigned int)opb;
-    giet_coproc_channel_init( 1 , &opb_desc );
+    giet_coproc_channel_init( cluster_xy,
+                              coproc_type,
+                              1, 
+                              &opb_desc );
     
-    //////////////////////// initializes channel for RES
+    // initializes RES channel
     giet_coproc_channel_t res_desc;
     res_desc.channel_mode = DMA_MODE;
     res_desc.buffer_size  = VECTOR_SIZE<<2;
     res_desc.buffer_vaddr = (unsigned int)res;
-    giet_coproc_channel_init( 2 , &res_desc );
+    giet_coproc_channel_init( cluster_xy,
+                              coproc_type,
+                              2, 
+                              &res_desc );
     
 #if  VERBOSE
@@ -94 +112 @@
 #endif
 
-    /////////////////////// starts communication channels
-    giet_coproc_run( 0 );
+    // starts coprocessor
+    giet_coproc_run( cluster_xy,
+                     coproc_type );
 
 #if  VERBOSE
@@ -101 +120 @@
 #endif
 
-    /////////////////////// wait coprocessor completion
+    // wait coprocessor completion
     if ( DMA_MODE == MODE_DMA_NO_IRQ )
     {
-        giet_coproc_completed( );
+        giet_coproc_completed( cluster_xy,
+                               coproc_type );
     }
 
@@ -118 +138 @@
     }
 
-    ////////////////////// release GCD coprocessor
-    giet_coproc_release( 0 );
+    // release GCD coprocessor
+    giet_coproc_release( cluster_xy,
+                         coproc_type );
 
     giet_pthread_exit("completed");

soft/giet_vm/applications/coproc/coproc.py

@@ -33 +33 @@
     x = 0
     y = 0
-    p = 1
+    p = 0
 
     assert( (x < x_size) and (y < y_size) )
@@ -50 +50 @@
 
     # create vspace
-    vspace = mapping.addVspace( name = 'coproc', startname = 'coproc_data', active = False )
+    vspace = mapping.addVspace( name = 'coproc', startname = 'coproc_data', active = True )
     
     # data vseg in cluster[x,y]

soft/giet_vm/applications/mjpeg/demux.c

@@ -86 +86 @@
     // giet_tty_alloc( 0 );
 
-    PRINTF("\n[MJPEG] thread DEMUX[%d] starts on P[%d,%d,%d]\n", index, x, y, p )
+    PRINTF("\n[MJPEG] thread DEMUX[%d] starts on P[%d,%d,%d] / trdid = %x\n", 
+           index , x , y , p, (uint32_t)trdid_demux[index] )
 
     // initialise BUFIO for MWMR channel <in>
@@ -95 +96 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%d] <in> : &mwmr = %x / &bufio = %x\n", 
-       index , mwmr_in , &bufio_in )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%d] <in> : &mwmr = %x / &bufio = %x\n", 
+         index , mwmr_in , &bufio_in ) }
 #endif
 
@@ -106 +108 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%d] : <out_quanti> : mwmr = %x / &bufio = %x\n",
-       index , mwmr_out_quanti , &bufio_out_quanti )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%d] : <out_quanti> : mwmr = %x / &bufio = %x\n",
+         index , mwmr_out_quanti , &bufio_out_quanti ) }
 #endif
 
@@ -117 +120 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%d] : <out_huff> : mwmr = %x / &bufio = %x\n",
-       index , mwmr_out_huff , &bufio_out_huff )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%d] : <out_huff> : mwmr = %x / &bufio = %x\n",
+         index , mwmr_out_huff , &bufio_out_huff ) }
 #endif
 
@@ -128 +132 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%d] : <out_data> : mwmr = %x / &bufio = %x\n",
-       index , mwmr_out_data , &bufio_out_data )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%d] : <out_data> : mwmr = %x / &bufio = %x\n",
+         index , mwmr_out_data , &bufio_out_data ) }
 #endif
 
@@ -150 +155 @@
             marker = get_next_marker( &bufio_in );
 
-#if (DEBUG_DEMUX > 1)
-if ( marker == SOI_MK ) PRINTF("\nDEMUX[%x] found Start of Image marker\n", index )
-#endif
         } 
         while ( marker != SOI_MK );
+
+#if (DEBUG_DEMUX > 1)
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Start of Image marker\n", index ) }
+#endif
 
         found_marker = 0;
@@ -173 +180 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found Start of Frame marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Start of Frame marker\n", index ) }
 #endif
                 // Only one component per image is supported
@@ -208 +216 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found Quantization Table marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Quantization Table marker\n", index ) }
 #endif
                 // The  quantisation table segment being fixed length, 
@@ -235 +244 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found Huffman Table marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Huffman Table marker\n", index ) }
 #endif
                 // The Huffman Table segment being variable length, 
@@ -279 +289 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found Start of Scan marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Start of Scan marker\n", index ) }
 #endif
                 // The scan segment has a variable length: 
@@ -330 +341 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found End of Image marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found End of Image marker\n", index ) }
 #endif
                 mwmr_bufio_flush( &bufio_out_data );
@@ -341 +353 @@
 
 #if (DEBUG_DEMUX > 1)
-PRINTF("\nDEMUX[%x] found Comment or Application marker\n", index )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%x] found Comment or Application marker\n", index ) }
 #endif
                 // read segment length from bufio_in
@@ -367 +380 @@
 
 #if DEBUG_DEMUX
-PRINTF("\nDEMUX[%d] completes image %d at cycle %d\n", index , image , giet_proctime() )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nDEMUX[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
 #endif
         image = image + x_size * y_size;
@@ -373 +387 @@
     }  // end while on images
 
-    giet_pthread_exit( "demux completed" );
+    giet_pthread_exit( "DEMUX completed" );
 
 }  // end demux()

soft/giet_vm/applications/mjpeg/idct.c

@@ -155 +155 @@
     // giet_tty_alloc( 0 );
 
-    PRINTF("\n[MJPEG] thread IDCT[%d] starts on P[%d,%d,%d]\n", index , x , y , p )
+    PRINTF("\n[MJPEG] thread IDCT[%d] starts on P[%d,%d,%d] / trdid = %x\n",
+           index , x , y , p, (uint32_t)trdid_idct[index] )
+
 
     uint32_t  image = index;
@@ -210 +212 @@
             mwmr_write( output, (uint32_t*)bout , 16 );
 
-#if (DEBUG_IDCT > 1) 
-PRINTF("\nIDCT[%d] completes block %d/%d in image %d\n", 
-       index , block , nblocks , image )
-PRINTF("  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n"
-       "  %x  %x  %x  %x  %x  %x  %x  %x\n",
-       bout[0] , bout[1] , bout[2] , bout[3] , bout[4] , bout[5] , bout[6] , bout[7] ,
-       bout[8] , bout[9] , bout[10], bout[11], bout[12], bout[13], bout[14], bout[15],
-       bout[16], bout[17], bout[18], bout[19], bout[20], bout[21], bout[22], bout[23],
-       bout[24], bout[25], bout[26], bout[27], bout[28], bout[29], bout[30], bout[31],
-       bout[32], bout[33], bout[34], bout[35], bout[36], bout[37], bout[38], bout[39],
-       bout[40], bout[41], bout[42], bout[43], bout[44], bout[45], bout[46], bout[47],
-       bout[48], bout[49], bout[50], bout[51], bout[52], bout[53], bout[54], bout[55],
-       bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63])
+#if (DEBUG_IDCT > 1)
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+ PRINTF("\nIDCT[%d] completes block %d/%d in image %d\n" 
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n"
+         "  %x  %x  %x  %x  %x  %x  %x  %x\n",
+         index , block , nblocks , image ,
+         bout[0] , bout[1] , bout[2] , bout[3] , bout[4] , bout[5] , bout[6] , bout[7] ,
+         bout[8] , bout[9] , bout[10], bout[11], bout[12], bout[13], bout[14], bout[15],
+         bout[16], bout[17], bout[18], bout[19], bout[20], bout[21], bout[22], bout[23],
+         bout[24], bout[25], bout[26], bout[27], bout[28], bout[29], bout[30], bout[31],
+         bout[32], bout[33], bout[34], bout[35], bout[36], bout[37], bout[38], bout[39],
+         bout[40], bout[41], bout[42], bout[43], bout[44], bout[45], bout[46], bout[47],
+         bout[48], bout[49], bout[50], bout[51], bout[52], bout[53], bout[54], bout[55],
+         bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]) }
 }
 #endif
@@ -234 +237 @@
 
 #if DEBUG_IDCT
-PRINTF("IDCT[%d] completes image %d at cycle %d\n", index , image , giet_proctime() )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nIDCT[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
 #endif
 
@@ -241 +245 @@
     }  // end while (1) on images
 
-    giet_pthread_exit( "idct completed" );
+    giet_pthread_exit( "IDCT completed" );
 
 }  // end idct()

soft/giet_vm/applications/mjpeg/iqzz.c

@@ -39 +39 @@
     uint32_t    block;
     uint32_t    i;
-    uint8_t     QTable[64];    // Quantisation Table / 1 byte per pixel
-    int16_t     bufin[64];     // Input data buffer  / 2 bytes per pixel
-    int32_t     bufout[64];    // Output data buffer / 4 bytes per pixel 
+    uint8_t     QT[64];      // Quantisation Table / 1 byte per pixel
+    int16_t     bin[64];     // Input data buffer  / 2 bytes per pixel
+    int32_t     bout[64];    // Output data buffer / 4 bytes per pixel 
 
     uint32_t    nblocks = nblocks_w * nblocks_h;
@@ -55 +55 @@
     giet_proc_xyp( &x , &y , &p );
 
-    PRINTF("\n[MJPEG] thread IQZZ[%d] starts on P[%d,%d,%d]\n", index, x, y, p )
+    PRINTF("\n[MJPEG] thread IQZZ[%d] starts on P[%d,%d,%d] / trdid = %x\n",
+           index , x , y , p, (uint32_t)trdid_iqzz[index] )
+
 
     uint32_t image = index;
@@ -62 +64 @@
     {
         // read the quantization coefs from mwmr_in_quanti (one byte per coef) 
-        mwmr_read( mwmr_in_quanti , (uint32_t*)QTable , 16 );
+        mwmr_read( mwmr_in_quanti , (uint32_t*)QT , 16 );
 
 #if (DEBUG_IQZZ > 1)
-PRINTF("\nIQZZ[%d] get quantisation coefs for image %d\n", index , image )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nIQZZ[%d] get quantisation coefs for image %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n"
+         "%d  %d  %d  %d  %d  %d  %d  %d\n",
+         index , image ,
+         QT[ 0],QT[ 1],QT[ 2],QT[ 3],QT[ 4],QT[ 5],QT[ 6],QT[ 7],
+         QT[ 8],QT[ 9],QT[10],QT[11],QT[12],QT[13],QT[14],QT[15],
+         QT[16],QT[17],QT[18],QT[19],QT[20],QT[21],QT[22],QT[23],
+         QT[24],QT[25],QT[26],QT[27],QT[28],QT[29],QT[30],QT[31],
+         QT[32],QT[33],QT[34],QT[35],QT[36],QT[37],QT[38],QT[39],
+         QT[40],QT[41],QT[42],QT[43],QT[44],QT[45],QT[46],QT[47],
+         QT[48],QT[49],QT[50],QT[51],QT[52],QT[53],QT[54],QT[55],
+         QT[56],QT[57],QT[58],QT[59],QT[60],QT[61],QT[62],QT[63] ) }
 #endif
 
@@ -71 +91 @@
         {
             // read one block from mwmr_in_data (2 bytes per pixel)
-            mwmr_read( mwmr_in_data , (uint32_t*)bufin , 32 );
+            mwmr_read( mwmr_in_data , (uint32_t*)bin , 32 );
 
             // unquantify & UnZZ each pixel
             for ( i = 0 ; i < 64 ; ++i ) 
             {
-                bufout[G_ZZ[i]] = bufin[i] * QTable[i];
+                bout[G_ZZ[i]] = bin[i] * QT[i];
             }
-    
+
             // write one block to IDCT / 4 bytes per pixel
-            mwmr_write( mwmr_out_data , (uint32_t*)bufout , 64 );
+            mwmr_write( mwmr_out_data , (uint32_t*)bout , 64 );
 
 #if (DEBUG_IQZZ > 1) 
-PRINTF("\nIQZZ[%d] completes block %d/%d in image %d\n", 
-       index , block , nblocks , image )
-PRINTF("  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n",
-       bufout[0] , bufout[1] , bufout[2] , bufout[3] , bufout[4] , bufout[5] , bufout[6] , bufout[7] ,
-       bufout[8] , bufout[9] , bufout[10], bufout[11], bufout[12], bufout[13], bufout[14], bufout[15],
-       bufout[16], bufout[17], bufout[18], bufout[19], bufout[20], bufout[21], bufout[22], bufout[23],
-       bufout[24], bufout[25], bufout[26], bufout[27], bufout[28], bufout[29], bufout[30], bufout[31],
-       bufout[32], bufout[33], bufout[34], bufout[35], bufout[36], bufout[37], bufout[38], bufout[39],
-       bufout[40], bufout[41], bufout[42], bufout[43], bufout[44], bufout[45], bufout[46], bufout[47],
-       bufout[48], bufout[49], bufout[50], bufout[51], bufout[52], bufout[53], bufout[54], bufout[55],
-       bufout[56], bufout[57], bufout[58], bufout[59], bufout[60], bufout[61], bufout[62], bufout[63])
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nIQZZ[%d] completes block %d/%d in image %d\n" 
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n",
+         index , block , nblocks , image ,
+         bout[0] , bout[1] , bout[2] , bout[3] , bout[4] , bout[5] , bout[6] , bout[7] ,
+         bout[8] , bout[9] , bout[10], bout[11], bout[12], bout[13], bout[14], bout[15],
+         bout[16], bout[17], bout[18], bout[19], bout[20], bout[21], bout[22], bout[23],
+         bout[24], bout[25], bout[26], bout[27], bout[28], bout[29], bout[30], bout[31],
+         bout[32], bout[33], bout[34], bout[35], bout[36], bout[37], bout[38], bout[39],
+         bout[40], bout[41], bout[42], bout[43], bout[44], bout[45], bout[46], bout[47],
+         bout[48], bout[49], bout[50], bout[51], bout[52], bout[53], bout[54], bout[55],
+         bout[56], bout[57], bout[58], bout[59], bout[60], bout[61], bout[62], bout[63]) }
 #endif
         }  // end for blocks
 
 #if DEBUG_IQZZ
-PRINTF("\nIQZZ[%d] completes image %d at cycle %d\n", index , image , giet_proctime() )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nIQZZ[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
 #endif
 
@@ -112 +134 @@
     } // end while(1) on images
 
-    giet_pthread_exit( "iqzz completed" );
+    giet_pthread_exit( "IQZZ completed" );
 
 } // end iqzz()

soft/giet_vm/applications/mjpeg/libu.c

@@ -52 +52 @@
     // giet_tty_alloc( 0 );
 
-    PRINTF("\n[MJPEG] thread LIBU[%d] starts on P[%d,%d,%d]\n", index , x , y , p )
+    PRINTF("\n[MJPEG] thread LIBU[%d] starts on P[%d,%d,%d] / trdid = %x\n",
+           index , x , y , p, (uint32_t)trdid_libu[index] )
 
     uint32_t image = index;
@@ -83 +84 @@
 
 #if (DEBUG_LIBU > 1)
-PRINTF("\nLIBU[%d] copy block[%d] for image %d\n", 
-index, line * nblocks_w + column , image )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nLIBU[%d] copy block[%d] for image %d\n", 
+         index, line * nblocks_w + column , image ) }
 #endif 
             }
@@ -97 +99 @@
 
 #if DEBUG_LIBU
-PRINTF("\nLIBU[%d] completes image %d at cycle %d\n", index , image , time )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nLIBU[%d] completes image %d at cycle %d\n", index , image , time ) }
 #endif
         // register date of display for instrumentation
@@ -106 +109 @@
     }  // end while on images
 
-    giet_pthread_exit( "libu completed" );
+    giet_pthread_exit( "LIBU completed" );
 
 }  // end libu()

soft/giet_vm/applications/mjpeg/mjpeg.c

@@ -26 +26 @@
 #include <stdlib.h>
 #include "mjpeg.h"
+#include <mapping_info.h>     // for coprocessor types and modes
 
 
@@ -39 +40 @@
 uint32_t         fd;    // file descriptor for the file containing the MJPEG stream
 
+// arrays of pointers on MWMR channels
 mwmr_channel_t*  tg_2_demux[256];         // one per cluster
 mwmr_channel_t*  demux_2_vld_data[256];   // one per cluster
@@ -46 +48 @@
 mwmr_channel_t*  iqzz_2_idct[256];        // one per cluster
 mwmr_channel_t*  idct_2_libu[256];        // one per cluster
+
+// thread trdid ( for pthread_create() and pthread_join() )
+pthread_t   trdid_tg; 
+pthread_t   trdid_demux[256];             // one per cluster
+pthread_t   trdid_vld[256];               // one per cluster
+pthread_t   trdid_iqzz[256];              // one per cluster 
+pthread_t   trdid_idct[256];              // one per cluster 
+pthread_t   trdid_libu[256];              // one per cluster 
 
 user_lock_t      tty_lock;                // lock protecting shared TTY
@@ -113 +123 @@
     uint32_t      image_height;
 
-    PRINTF("\n[MJPEG] enter path for JPEG stream file\n> ");  
-    giet_tty_gets( file_pathname , 256 );
-
-    if ( file_pathname[0] == 0 )
+    if ( INTERACTIVE_MODE )
+    {
+        PRINTF("\n[MJPEG] enter path for JPEG stream file (default is plan_48.mjpg)\n> ") 
+        giet_tty_gets( file_pathname , 256 );
+
+        if ( file_pathname[0] == 0 )
+        {
+            strcpy( file_pathname , "/misc/plan_48.mjpg" );
+            image_width  = 48;
+            image_height = 48;
+        }
+        else
+        {
+            PRINTF("\n[MJPEG] enter image width\n> ")  
+            giet_tty_getw( &image_width );
+            PRINTF("\n[MJPEG] enter image height\n> ")  
+            giet_tty_getw( &image_height );
+            PRINTF("\n") 
+        }
+    }
+    else
     {
         strcpy( file_pathname , "/misc/plan_48.mjpg" );
         image_width  = 48;
         image_height = 48;
-        PRINTF("\n\n[MJPEG] use /misc/plan_48.mjpg\n" );
-    }
-    else
-    {
-        PRINTF("\n[MJPEG] enter image width\n> ");  
-        giet_tty_getw( &image_width );
-        PRINTF("\n[MJPEG] enter image height\n> ");  
-        giet_tty_getw( &image_height );
-        PRINTF("\n"); 
-    }
-
+    }
+    
     giet_pthread_assert( (image_width == fbf_width) && (image_height == fbf_height) ,
                          "[MJPEG ERROR] image size doesn't fit frame buffer size");
  
+    PRINTF("\n\n[MJPEG] starts for stream %s\n", file_pathname )
+
     // compute nblocks_h & nblocks_w
     nblocks_w = fbf_width / 8;
@@ -201 +221 @@
 
     // start CMA channel
-    giet_fbf_cma_start( );
-
-    PRINTF("\n[MJPEG] main thread completes initialisation for %d cores\n", 
+    giet_fbf_cma_start();
+
+    PRINTF("\n[MJPEG] main thread completes initialisation for %d cores\n",
            x_size * y_size * nprocs )
 
-    // thread trdid for pthread_create() and pthread_join()
-    pthread_t   trdid_tg; 
-    pthread_t   trdid_demux[256]; 
-    pthread_t   trdid_vld[256]; 
-    pthread_t   trdid_iqzz[256]; 
-    pthread_t   trdid_idct[256]; 
-    pthread_t   trdid_libu[256]; 
-
+    mwmr_channel_t* ptr;
+
+    for ( n = 0 ; n < x_size*y_size ; n++ )
+    {
+        ptr = tg_2_demux[n];
+        PRINTF(" - tg_2_demux[%d]  = %x / &lock = %x / &buf = %x / size = %d\n",
+               n, ptr, (uint32_t)&ptr->lock, (uint32_t)ptr->data, ptr->depth<<2 ) 
+
+        ptr = demux_2_vld_data[n];
+        PRINTF(" - demux_2_vld[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
+               n, ptr, (uint32_t)&ptr->lock, (uint32_t)ptr->data, ptr->depth<<2 ) 
+
+        ptr = vld_2_iqzz[n];
+        PRINTF(" - vld_2_iqzz[%d]  = %x / &lock = %x / &buf = %x / size = %d\n",
+               n, ptr, (uint32_t)&ptr->lock, (uint32_t)ptr->data, ptr->depth<<2 ) 
+
+        ptr = iqzz_2_idct[n];
+        PRINTF(" - iqzz_2_idct[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
+               n, ptr, (uint32_t)&ptr->lock, (uint32_t)ptr->data, ptr->depth<<2 ) 
+
+        ptr = idct_2_libu[n];
+        PRINTF(" - idct_2_libu[%d] = %x / &lock = %x / &buf = %x / size = %d\n",
+               n, ptr, (uint32_t)&ptr->lock, (uint32_t)ptr->data, ptr->depth<<2 ) 
+    }
+
+    // launch all threads : precise mapping is defined in the mjpeg.py file
     uint32_t index;
-
-    // launch all threads : precise mapping is defined in the mjpeg.py file
 
     if ( giet_pthread_create( &trdid_tg, NULL, &tg , NULL ) )
     giet_pthread_exit( "error launching thread tg\n");
 
-    for ( index = 0 ; index < (x_size * y_size) ; index++ )
-    {
-        if ( giet_pthread_create( &trdid_demux[index], NULL, &demux , (void*)index ) )
-        giet_pthread_exit( "error launching thread demux\n");
-
-        if ( giet_pthread_create( &trdid_vld[index], NULL, &vld , (void*)index ) )
-        giet_pthread_exit( "error launching thread vld\n");
-
-        if ( giet_pthread_create( &trdid_iqzz[index], NULL, &iqzz , (void*)index ) )
-        giet_pthread_exit( "error launching thread iqzz");
-
-        if ( giet_pthread_create( &trdid_idct[index], NULL, &idct , (void*)index ) )
-        giet_pthread_exit( "error launching thread idct\n");
-
-        if ( giet_pthread_create( &trdid_libu[index], NULL, &libu , (void*)index ) )
-        giet_pthread_exit( "error launching thread libu\n");
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            index = x * y_size + y;
+
+            // DEMUX  
+            if ( giet_pthread_create( &trdid_demux[index], NULL, &demux , (void*)index ) )
+            giet_pthread_exit( "error launching thread demux\n");
+
+            // VLD
+            if ( giet_pthread_create( &trdid_vld[index], NULL, &vld , (void*)index ) )
+            giet_pthread_exit( "error launching thread vld\n");
+
+            // IQZZ
+            if ( giet_pthread_create( &trdid_iqzz[index], NULL, &iqzz , (void*)index ) )
+            giet_pthread_exit( "error launching thread iqzz");
+
+            // IDCT
+            if ( USE_DCT_COPROC )  // allocate, initialise, and start hardware coprocessor
+            {
+                giet_coproc_channel_t in_channel;
+                giet_coproc_channel_t out_channel;
+                uint32_t  cluster_xy  = (x<<4) + y;
+                uint32_t  coproc_type = 2;
+                uint32_t  info;
+
+                // allocate DCT coprocessor
+                giet_coproc_alloc( cluster_xy , coproc_type , &info );
+
+                // initialize channels
+                in_channel.channel_mode = MODE_MWMR;
+                in_channel.buffer_size  = (iqzz_2_idct[index]->depth)<<2;
+                in_channel.buffer_vaddr = (uint32_t)(iqzz_2_idct[index]->data);
+                in_channel.status_vaddr = (uint32_t)(&iqzz_2_idct[index]->sts);
+                in_channel.lock_vaddr   = (uint32_t)(&iqzz_2_idct[index]->lock);
+    
+                giet_coproc_channel_init( cluster_xy , coproc_type , 0 , &in_channel );
+
+                out_channel.channel_mode = MODE_MWMR;
+                out_channel.buffer_size  = (idct_2_libu[index]->depth)<<2;
+                out_channel.buffer_vaddr = (uint32_t)(idct_2_libu[index]->data);
+                out_channel.status_vaddr = (uint32_t)(&idct_2_libu[index]->sts);
+                out_channel.lock_vaddr   = (uint32_t)(&idct_2_libu[index]->lock);
+
+                giet_coproc_channel_init( cluster_xy , coproc_type , 1 , &out_channel );
+
+                // start coprocessor
+                giet_coproc_run( cluster_xy , coproc_type );
+            }
+            else                   // launches a software thread
+            {
+                if ( giet_pthread_create( &trdid_idct[index], NULL, &idct , (void*)index ) )
+                giet_pthread_exit( "error launching thread idct\n");
+            }
+
+            // LIBU
+            if ( giet_pthread_create( &trdid_libu[index], NULL, &libu , (void*)index ) )
+            giet_pthread_exit( "error launching thread libu\n");
+        }
     }
 
@@ -244 +324 @@
     { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for tg\n" ) }
 
-    for ( index = 0 ; index < (x_size * y_size) ; index++ )
-    {
-        if ( giet_pthread_join( trdid_demux[index] , NULL ) )
-        { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for demux[%d]\n", index ) }
-
-        if ( giet_pthread_join( trdid_vld[index] , NULL ) )
-        { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for vld[%d]\n", index ) }
-
-        if ( giet_pthread_join( trdid_iqzz[index] , NULL ) )
-        { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for iqzz[%d]\n", index ) }
-
-        if ( giet_pthread_join( trdid_idct[index] , NULL ) )
-        { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for idct[%d]\n", index ) }
-
-        if ( giet_pthread_join( trdid_libu[index] , NULL ) )
-        { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for libu[%d]\n", index ) }
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            index = x * y_size + y;
+
+            if ( giet_pthread_join( trdid_demux[index] , NULL ) )
+            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for demux[%d]\n", index ) }
+
+            if ( giet_pthread_join( trdid_vld[index] , NULL ) )
+            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for vld[%d]\n", index ) }
+
+            if ( giet_pthread_join( trdid_iqzz[index] , NULL ) )
+            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for iqzz[%d]\n", index ) }
+
+            if ( USE_DCT_COPROC == 0 )
+            {
+                if ( giet_pthread_join( trdid_idct[index] , NULL ) )
+                { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for idct[%d]\n", index ) }
+            }
+
+            if ( giet_pthread_join( trdid_libu[index] , NULL ) )
+            { PRINTF("\n[MJPEG ERROR] calling giet_pthread_join() for libu[%d]\n", index ) }
+
+            if ( USE_DCT_COPROC )
+            {
+                uint32_t  cluster_xy  = (x<<4) + y;
+                uint32_t  coproc_type = 2;
+                giet_coproc_release( cluster_xy , coproc_type );
+            }
+        }
     }
 

soft/giet_vm/applications/mjpeg/mjpeg.h

@@ -16 +16 @@
 #include <user_lock.h>
 
-#define   MAX_IMAGES  64
+////////////////////////////////////////////////////////////////////////////////////////
+//  Configuration Variables
+////////////////////////////////////////////////////////////////////////////////////////
+
+#define   MAX_IMAGES         16
+
+#define   USE_DCT_COPROC     1
+
+#define   INTERACTIVE_MODE   0
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -22 +30 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#define   TG_2_DEMUX_DEPTH          256 
-#define   DEMUX_2_VLD_DATA_DEPTH    256
-#define   DEMUX_2_VLD_HUFF_DEPTH    256
-#define   DEMUX_2_IQZZ_DEPTH        256
-#define   VLD_2_IQZZ_DEPTH          256
-#define   IQZZ_2_IDCT_DEPTH         256
-#define   IDCT_2_LIBU_DEPTH         256 
+#define   TG_2_DEMUX_DEPTH          1024
+#define   DEMUX_2_VLD_DATA_DEPTH    1024
+#define   DEMUX_2_VLD_HUFF_DEPTH    1024
+#define   DEMUX_2_IQZZ_DEPTH        1024
+#define   VLD_2_IQZZ_DEPTH          1024
+#define   IQZZ_2_IDCT_DEPTH         1024
+#define   IDCT_2_LIBU_DEPTH         1024
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -37 +45 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#define DEBUG_TG      1
-#define DEBUG_DEMUX   0
-#define DEBUG_VLD     0
-#define DEBUG_IQZZ    0
-#define DEBUG_IDCT    0
-#define DEBUG_LIBU    0
+#define DEBUG_CLUSTER_INDEX   0xFFFFFFFF   // use 0xFFFFFFFF for all clusters
+
+#define DEBUG_TG              1
+#define DEBUG_DEMUX           1
+#define DEBUG_VLD             1
+#define DEBUG_IQZZ            1
+#define DEBUG_IDCT            1
+#define DEBUG_LIBU            1
 
 ////////////////////////////////////////////////////////////////////////////////////////
-//       Global variables
+//       Global variables (allocated in mjpeg.c)
 ////////////////////////////////////////////////////////////////////////////////////////
 
@@ -57 +67 @@
 extern mwmr_channel_t*  iqzz_2_idct[256];        // one per cluster
 extern mwmr_channel_t*  idct_2_libu[256];        // one per cluster
+
+extern pthread_t        trdid_tg; 
+extern pthread_t        trdid_demux[256];        // one per cluster
+extern pthread_t        trdid_vld[256];          // one per cluster
+extern pthread_t        trdid_iqzz[256];         // one per cluster 
+extern pthread_t        trdid_idct[256];         // one per cluster 
+extern pthread_t        trdid_libu[256];         // one per cluster 
 
 extern user_lock_t      tty_lock;                // lock protecting shared TTY

soft/giet_vm/applications/mjpeg/mjpeg.py

@@ -32 +32 @@
     nprocs    = mapping.nprocs
 
-    assert (nprocs >= 1)
+    assert (nprocs >= 1) and (nprocs <= 4)
 
     # define vsegs base & size
@@ -42 +42 @@
 
     heap_base  = 0x30000000
-    heap_size  = 0x00100000     # 1M bytes (per cluster)      
+    heap_size  = 0x00200000     # 2 Mbytes (per cluster)      
 
     stack_base = 0x40000000 
@@ -49 +49 @@
     # create vspace
     vspace = mapping.addVspace( name = 'mjpeg', 
-                                startname = 'data', 
+                                startname = 'mjpeg_data', 
                                 active = True )
     
     # data vseg : shared / cluster[0][0]
-    mapping.addVseg( vspace, 'data', data_base , data_size, 
+    mapping.addVseg( vspace, 'mjpeg_data', data_base , data_size, 
                      'C_WU', vtype = 'ELF', x = 0, y = 0, pseg = 'RAM', 
                      binpath = 'bin/mjpeg/appli.elf',
@@ -66 +66 @@
                 base  = heap_base + (cluster_id * size)
 
-                mapping.addVseg( vspace, 'heap_%d_%d' %(x,y), base , size, 
+                mapping.addVseg( vspace, 'mjpeg_heap_%d_%d' %(x,y), base , size, 
                                  'C_WU', vtype = 'HEAP', x = x, y = y, pseg = 'RAM', 
                                  local = False, big = True )
@@ -76 +76 @@
             if ( mapping.clusters[cluster_id].procs ):
 
-                mapping.addVseg( vspace, 'code_%d_%d' %(x,y), 
+                mapping.addVseg( vspace, 'mjpeg_code_%d_%d' %(x,y), 
                                  code_base , code_size,
                                  'CXWU', vtype = 'ELF', x = x, y = y, pseg = 'RAM', 
@@ -85 +85 @@
     # ... plus main_stack and tg_stack in cluster[0][0]
     base = stack_base
-    mapping.addVseg( vspace, 'main_stack',
+    mapping.addVseg( vspace, 'mjpeg_main_stack',
                      base, stack_size, 'C_WU', vtype = 'BUFFER', 
                      x = 0 , y = 0 , pseg = 'RAM',
@@ -92 +92 @@
     base += stack_size
 
-    mapping.addVseg( vspace, 'tg_stack',
+    mapping.addVseg( vspace, 'mjpeg_tg_stack',
                      base , stack_size, 'C_WU', vtype = 'BUFFER', 
                      x = 0 , y = 0 , pseg = 'RAM',
@@ -103 +103 @@
             if ( mapping.clusters[cluster_id].procs ):
 
-                mapping.addVseg( vspace, 'demux_stack_%d_%d' % (x,y), 
-                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
-                                 x = x , y = y , pseg = 'RAM',
-                                 local = True )
-
-                base += stack_size
-
-                mapping.addVseg( vspace, 'vld_stack_%d_%d' % (x,y), 
-                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
-                                 x = x , y = y , pseg = 'RAM',
-                                 local = True )
-
-                base += stack_size
-
-                mapping.addVseg( vspace, 'iqzz_stack_%d_%d' % (x,y), 
-                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
-                                 x = x , y = y , pseg = 'RAM',
-                                 local = True )
-
-                base += stack_size
-
-                mapping.addVseg( vspace, 'idct_stack_%d_%d' % (x,y), 
-                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
-                                 x = x , y = y , pseg = 'RAM',
-                                 local = True )
-
-                base += stack_size
-
-                mapping.addVseg( vspace, 'libu_stack_%d_%d' % (x,y), 
+                mapping.addVseg( vspace, 'mjpeg_demux_stack_%d_%d' % (x,y), 
+                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
+                                 x = x , y = y , pseg = 'RAM',
+                                 local = True )
+
+                base += stack_size
+
+                mapping.addVseg( vspace, 'mjpeg_vld_stack_%d_%d' % (x,y), 
+                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
+                                 x = x , y = y , pseg = 'RAM',
+                                 local = True )
+
+                base += stack_size
+
+                mapping.addVseg( vspace, 'mjpeg_iqzz_stack_%d_%d' % (x,y), 
+                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
+                                 x = x , y = y , pseg = 'RAM',
+                                 local = True )
+
+                base += stack_size
+
+                mapping.addVseg( vspace, 'mjpeg_idct_stack_%d_%d' % (x,y), 
+                                 base, stack_size, 'C_WU', vtype = 'BUFFER', 
+                                 x = x , y = y , pseg = 'RAM',
+                                 local = True )
+
+                base += stack_size
+
+                mapping.addVseg( vspace, 'mjpeg_libu_stack_%d_%d' % (x,y), 
                                  base, stack_size, 'C_WU', vtype = 'BUFFER', 
                                  x = x , y = y , pseg = 'RAM',
@@ -139 +139 @@
 
     # threads mapping: demux, vld, iqzz, idct, libu replicated in all clusters
-    # ... plus main & tg on P[0,0,0]
+    # main & tg are mapped in cluster[0,0]
     mapping.addThread( vspace, 'main', True, 0, 0, 0,
-                       'main_stack',
-                       'heap_0_0',
+                       'mjpeg_main_stack',
+                       'mjpeg_heap_0_0',
                        0 )                      # index in start_vector
 
@@ -162 +162 @@
         p_tg    = 0
         p_demux = 1
-        p_vld   = 1
+        p_vld   = 2
         p_iqzz  = 1
-        p_idct  = 2
+        p_idct  = 1
         p_libu  = 1
     elif ( nprocs == 4 ):
         p_tg    = 0
         p_demux = 1
-        p_vld   = 2
+        p_vld   = 3
         p_iqzz  = 2
         p_idct  = 3
         p_libu  = 2
-    elif ( nprocs == 5 ):
-        p_tg    = 0
-        p_demux = 1
-        p_vld   = 2
-        p_iqzz  = 3
-        p_idct  = 4
-        p_libu  = 3
-    else:
-        p_tg    = 0
-        p_demux = 1
-        p_vld   = 2
-        p_iqzz  = 3
-        p_idct  = 4
-        p_libu  = 5
     
     mapping.addThread( vspace, 'tg', False, 0, 0, p_tg,
-                       'tg_stack',
-                       'heap_0_0',
+                       'mjpeg_tg_stack',
+                       'mjpeg_heap_0_0',
                        1 )                      # index in start_vector
 
@@ -198 +184 @@
 
                 mapping.addThread( vspace, 'demux_%d_%d' % (x,y), False , x, y, p_demux,
-                                   'demux_stack_%d_%d' % (x,y), 
-                                   'heap_%d_%d' % (x,y),
+                                   'mjpeg_demux_stack_%d_%d' % (x,y), 
+                                   'mjpeg_heap_%d_%d' % (x,y),
                                    2 )   # start_index  
 
                 mapping.addThread( vspace, 'vld_%d_%d' % (x,y), False , x, y, p_vld,
-                                   'vld_stack_%d_%d' % (x,y), 
-                                   'heap_%d_%d' % (x,y),
+                                   'mjpeg_vld_stack_%d_%d' % (x,y), 
+                                   'mjpeg_heap_%d_%d' % (x,y),
                                    3 )   # start_index  
 
                 mapping.addThread( vspace, 'iqzz_%d_%d' % (x,y), False , x, y, p_iqzz,
-                                   'iqzz_stack_%d_%d' % (x,y), 
-                                   'heap_%d_%d' % (x,y),
+                                   'mjpeg_iqzz_stack_%d_%d' % (x,y), 
+                                   'mjpeg_heap_%d_%d' % (x,y),
                                    4 )   # start_index  
 
                 mapping.addThread( vspace, 'idct_%d_%d' % (x,y), False , x, y, p_idct,
-                                   'idct_stack_%d_%d' % (x,y), 
-                                   'heap_%d_%d' % (x,y),
+                                   'mjpeg_idct_stack_%d_%d' % (x,y), 
+                                   'mjpeg_heap_%d_%d' % (x,y),
                                    5 )   # start_index  
 
                 mapping.addThread( vspace, 'libu_%d_%d' % (x,y), False , x, y, p_libu,
-                                   'libu_stack_%d_%d' % (x,y), 
-                                   'heap_%d_%d' % (x,y),
+                                   'mjpeg_libu_stack_%d_%d' % (x,y), 
+                                   'mjpeg_heap_%d_%d' % (x,y),
                                    6 )   # start_index  
 

soft/giet_vm/applications/mjpeg/tg.c

@@ -39 +39 @@
     //  giet_tty_alloc( 0 );
 
-    PRINTF("\n[MJPEG] thread TG starts on P[%d,%d,%d]\n", x , y , p )
+    PRINTF("\n[MJPEG] thread TG starts on P[%d,%d,%d] / trdid = %x\n",
+           x , y , p , (uint32_t)trdid_tg )
 
    // allocate input buffer : 1024 bytes

soft/giet_vm/applications/mjpeg/vld.c

@@ -193 +193 @@
 }
 
-////////////////////////////////////////////
-void huff_tables_load( huff_tables_t*  huff,
+/////////////////////////////////////////////
+void huff_tables_load( uint32_t        index,
+                       huff_tables_t*  huff,
                        mwmr_bufio_t*   bufio )
 {
@@ -253 +254 @@
     mwmr_bufio_align( bufio );
     
-#if (DEBUG_VLD > 2) 
+#if (DEBUG_VLD > 3) 
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
 huff_tables_dump( huff , is_ac );
 #endif
@@ -312 +314 @@
 // unpack a 8*8 pixels block with 2 bytes per pixel
 //////////////////////////////////////////////////////////
-static int16_t vld_unpack_block( bitreader_t*      stream, 
-                                 mwmr_channel_t*   mwmr_out, 
-                                 huff_tables_t*    huff,
-                                 int16_t           prev_dc )
+static int16_t vld_unpack_block( uint32_t          index,     // cluster index
+                                 uint32_t          image,     // image index
+                                 uint32_t          block,     // block index
+                                 bitreader_t*      stream,    // input bit stream
+                                 mwmr_channel_t*   mwmr_out,  // output channel
+                                 huff_tables_t*    huff,      // Huffman Tables
+                                 int16_t           prev_dc )  // previous DC coef
 {
     uint32_t temp;
@@ -335 +340 @@
     buf[0]   = value + prev_dc;
 
-#if (DEBUG_VLD > 1)
-PRINTF("\nDC[0] = %d / reformat( %x , %d ) = %d\n", buf[0], temp , symbol , value )
+#if (DEBUG_VLD > 2)
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] : DC[0] = %d / reformat( %x , %d ) = %d\n",
+         index , buf[0], temp , symbol , value ) }
 #endif
 
@@ -348 +355 @@
         {
 
-#if (DEBUG_VLD > 1)
-PRINTF("EOB found at i = %d\n", i );
+#if (DEBUG_VLD > 2)
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] : EOB found at i = %d\n", index , i ) }
 #endif 
             break;
@@ -370 +378 @@
 
 #if (DEBUG_VLD > 2)
-PRINTF("AC[%d] = %d / reformat( %x , %d ) = %d\n", i , buf[i] , temp , cat , value )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] : AC[%d] = %d / reformat( %x , %d ) = %d\n",
+         index , i , buf[i] , temp , cat , value ) }
 #endif
 
@@ -379 +389 @@
 
 #if (DEBUG_VLD > 1 )
-PRINTF("  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n"
-       "  %d  %d  %d  %d  %d  %d  %d  %d\n",
-       buf[0] , buf[1] , buf[2] , buf[3] , buf[4] , buf[5] , buf[6] , buf[7] ,
-       buf[8] , buf[9] , buf[10], buf[11], buf[12], buf[13], buf[14], buf[15],
-       buf[16], buf[17], buf[18], buf[19], buf[20], buf[21], buf[22], buf[23],
-       buf[24], buf[25], buf[26], buf[27], buf[28], buf[29], buf[30], buf[31],
-       buf[32], buf[33], buf[34], buf[35], buf[36], buf[37], buf[38], buf[39],
-       buf[40], buf[41], buf[42], buf[43], buf[44], buf[45], buf[46], buf[47],
-       buf[48], buf[49], buf[50], buf[51], buf[52], buf[53], buf[54], buf[55],
-       buf[56], buf[57], buf[58], buf[59], buf[60], buf[61], buf[62], buf[63])
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] completes block %d/%d in image %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n"
+         "  %d  %d  %d  %d  %d  %d  %d  %d\n",
+         index , block , nblocks_w*nblocks_h , image ,
+         buf[0] , buf[1] , buf[2] , buf[3] , buf[4] , buf[5] , buf[6] , buf[7] ,
+         buf[8] , buf[9] , buf[10], buf[11], buf[12], buf[13], buf[14], buf[15],
+         buf[16], buf[17], buf[18], buf[19], buf[20], buf[21], buf[22], buf[23],
+         buf[24], buf[25], buf[26], buf[27], buf[28], buf[29], buf[30], buf[31],
+         buf[32], buf[33], buf[34], buf[35], buf[36], buf[37], buf[38], buf[39],
+         buf[40], buf[41], buf[42], buf[43], buf[44], buf[45], buf[46], buf[47],
+         buf[48], buf[49], buf[50], buf[51], buf[52], buf[53], buf[54], buf[55],
+         buf[56], buf[57], buf[58], buf[59], buf[60], buf[61], buf[62], buf[63]) }
 #endif
 
@@ -428 +441 @@
     // giet_tty_alloc( 0 );
 
-    PRINTF("\n[MJPEG] thread VLD[%d] starts on P[%d,%d,%d]\n" , index, x, y ,p )
+    PRINTF("\n[MJPEG] thread VLD[%d] starts on P[%d,%d,%d] / trdid = %x\n",
+           index , x , y , p, (uint32_t)trdid_vld[index] )
+
 
     // initialise BUFIO for MWMR channel <in_data>
@@ -436 +451 @@
 
 #if (DEBUG_VLD > 1)
-PRINTF("\nVLD[%d] <in_data> : &mwmr = %x / &bufio = %x\n",
-       index , mwmr_in_data , &bufio_in_data )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] <in_data> : &mwmr = %x / &bufio = %x\n",
+         index , mwmr_in_data , &bufio_in_data ) }
 #endif
 
@@ -446 +462 @@
 
 #if (DEBUG_VLD > 1)
-PRINTF("\nVLD[%d] <in_huff> : &mwmr = %x / &bufio = %x\n",
-       index , mwmr_in_huff , &bufio_in_huff )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] <in_huff> : &mwmr = %x / &bufio = %x\n",
+         index , mwmr_in_huff , &bufio_in_huff ) }
 #endif
 
@@ -459 +476 @@
     {
         // load first Huffman Table from bufio_in_huff
-        huff_tables_load( &huff , &bufio_in_huff );
+        huff_tables_load( index, &huff , &bufio_in_huff );
 
         // load second Huffman Table from bufio_in_huff
-        huff_tables_load( &huff , &bufio_in_huff );
+        huff_tables_load( index, &huff , &bufio_in_huff );
 
 #if (DEBUG_VLD > 1)
-PRINTF("\nVLD[%d] load Huffman tables for image %d\n", index , image )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] load Huffman tables for image %d\n", index , image ) }
 #endif
 
@@ -482 +500 @@
 
 #if (DEBUG_VLD > 1) 
-PRINTF("\nVLD[%d] uncompress block %d/%d in image %d\n", index, block, nblocks, image )
-#endif
-            prev_dc = vld_unpack_block( &stream , mwmr_out, &huff , prev_dc );
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] uncompress block %d/%d in image %d\n", index, block, nblocks, image ) }
+#endif
+            prev_dc = vld_unpack_block( index,
+                                        image,
+                                        block,
+                                        &stream, 
+                                        mwmr_out, 
+                                        &huff, 
+                                        prev_dc );
         }  // end for blocks
 
 #if DEBUG_VLD 
-PRINTF("\nVLD[%d] completes image %d at cycle %d\n", index , image , giet_proctime() )
+if ( (index == DEBUG_CLUSTER_INDEX) || (DEBUG_CLUSTER_INDEX == 0XFFFFFFFF) )
+{ PRINTF("\nVLD[%d] completes image %d at cycle %d\n", index , image , giet_proctime() ) }
 #endif
         image = image + x_size*y_size;
@@ -494 +520 @@
     }  // end while on images
 
-    giet_pthread_exit( "vld completed" );
+    giet_pthread_exit( "VLD completed" );
 
 }  // end vld()