Changeset 676

Timestamp:

Nov 20, 2020, 12:11:35 AM (4 years ago)

Author:

alain

Message:

Introduce chat application to test the named pipes.

Location:

trunk/user

Files:

• chat (added)
• chat/Makefile (added)
• chat/chat.c (added)
• chat/chat.ld (added)
• convol/convol.c (modified) (49 diffs)
• display/display.c (modified) (4 diffs)
• init/init.c (modified) (8 diffs)
• kleenex/kleenex.c (modified) (4 diffs)
• ksh/ksh.c (modified) (47 diffs)
• sort/sort.c (modified) (1 diff)
• tcp_client/tcp_client.c (modified) (8 diffs)
• tcp_server/tcp_server.c (modified) (9 diffs)
• transpose/transpose.c (modified) (23 diffs)

trunk/user/convol/convol.c

@@ -8 +8 @@
 // per core, and uses the POSIX threads API.
 // 
-// The main() function can be launched on any processor P[x,y,l].
-// It makes the initialisations, launch (N-1) threads to run the execute() function
-// on the (N-1) other processors than P[x,y,l], call himself the execute() function, 
-// and finally call the instrument() function to display instrumentation results 
-// when the parallel execution is completed.
+// The input image is read from a file and the output image is saved to another file.
+//
+// - number of clusters containing processors must be power of 2 no larger than 256.
+// - number of processors per cluster must be power of 2 no larger than 4.
+// - number of working threads is the number of cores availables in the hardware
+//   architecture : nthreads = nclusters * ncores.
 //
 // The convolution kernel is defined in the execute() function.
 // It can be factored in two independant line and column convolution products.
-// The five buffers containing the image are distributed in clusters.
-// For the philips image, it is a [201]*[35] pixels rectangle, and the.
-// 
-// The (1024 * 1024) pixels image is read from a file (2 bytes per pixel).
 //
-// - number of clusters containing processors must be power of 2 no larger than 256.
-// - number of processors per cluster must be power of 2 no larger than 4.
+// The main() function can be launched on any processor.
+// - It checks software requirements versus the hardware resources.
+// - It open & maps the input file to a global <image_in> buffer.
+// - it open & maps the output file to another global <image_out> buffer.
+// - it open the instrumentation file.
+// - it creates & activates two FBF windows to display input & output images.
+// - it launches other threads to run in parallel the execute() function.
+// - it saves the instrumentation results on disk.
+// - it closes the input, output, & instrumentation files.
+// - it deletes the FBF input & output windows.
 //
-// The number N of working threads is always defined by the number of cores availables
-// in the architecture, but this application supports three placement modes.
+// The execute() function is executed in parallel by all threads. These threads are
+// working on 5 arrays of distributed buffers, indexed by the cluster index [cid].
+// - A[cid]: contain the distributed initial image (NL/NCLUSTERS lines per cluster).
+// - B[cid]: is the result of horizontal filter, then transpose B <= Trsp(HF(A)
+// - C[cid]: is the result of vertical image, then transpose : c <= Trsp(VF(B)
+// - D[cid]: is the the difference between A and FH(A) : D <= A - FH(A)
+// - Z[cid]: contain the distributed final image Z <= C + D
+//
+// It can be split in four phases separated by synchronisation barriers:
+// 1. Initialisation:
+//    Allocates the 5 A[cid],B[cid],C[cid],D[cid],Z[cid] buffers, initialise A[cid]
+//    from the <image_in> buffer, and display the initial image on FBF if rquired.
+// 2. Horizontal Filter:
+//    Set B[cid] and D[cid] from A[cid]. Read data accesses are local, write data
+//    accesses are remote, to implement the transpose. 
+// 3. Vertical Filter:  
+//    Set C[cid] from B[cid]. Read data accesses are local, write data accesses 
+//    are remote, to implement the transpose.
+// 4. Save results:
+//    Set the Z[cid] from C[cid] and D[cid]. All read and write access are local.
+//    Move the final image (Z[cid] buffer) to the <image_out> buffer.   
+//
+// This application supports three placement modes, implemented in the main() function.
 // In all modes, the working threads are identified by the [tid] continuous index 
 // in range [0, NTHREADS-1], and defines how the lines are shared amongst the threads.
 // This continuous index can always be decomposed in two continuous sub-indexes:
-// tid == cid * ncores + lid,  where cid is in [0,NCLUSTERS-1] and lid in [0,NCORES-1].
+// tid == cid * NCORES + lid,  where cid is in [0,NCLUSTERS-1] and lid in [0,NCORES-1].
 //
 // - NO_PLACEMENT: the main thread is itsef a working thread. The (N_1) other working
@@ -38 +64 @@
 //   but has tid = 0 (i.e. cid = 0 & tid = 0).
 //
-// - EXPLICIT_PLACEMENT: the main thread is again a working thread, but the placement of
+// - EXPLICIT_PLACEMENT: the main thread is again a working thread, but the placement 
 //   of the threads on the cores is explicitely controled by the main thread to have
 //   exactly one working thread per core, and the [cxy][lpid] core coordinates for a given
@@ -46 +72 @@
 // - PARALLEL_PLACEMENT: the main thread is not anymore a working thread, and uses the
 //   non standard pthread_parallel_create() function to avoid the costly sequencial
-//   loops for pthread_create() and pthread_join(). It garanty one working thread 
+//   loops for pthread_create() and pthread_join(). It garanties one working thread 
 //   per core, and the same relation between the thread[tid] and the core[cxy][lpid].
 //
@@ -65 +91 @@
 
 #define VERBOSE_MAIN               1
-#define VERBOSE_EXEC               0
+#define VERBOSE_EXEC               1
 #define SUPER_VERBOSE              0
 
@@ -74 +100 @@
 #define THREADS_MAX                (X_MAX * Y_MAX * CORES_MAX)
 
-#define IMAGE_IN_PATH              "misc/philips_1024_2.raw"
-#define IMAGE_IN_PIXEL_SIZE        2                               // 2 bytes per pixel
-
-#define IMAGE_OUT_PATH             "misc/philips_after_1O24.raw"
-#define IMAGE_OUT_PIXEL_SIZE       1                               // 1 bytes per pixel
-
-#define FBF_TYPE                   420 
-#define NL                         1024
-#define NP                         1024
-#define NB_PIXELS                  (NP * NL)
+#define IMAGE_TYPE                 420                         // pixel encoding type
+#define INPUT_IMAGE_PATH           "misc/couple_512.raw"       // default image_in
+#define OUTPUT_IMAGE_PATH          "misc/couple_conv_512.raw"  // default image_out
+#define NL                         512                         // default nlines
+#define NP                         512                         // default npixels
 
 #define NO_PLACEMENT               0
@@ -89 +110 @@
 #define PARALLEL_PLACEMENT         1
 
+#define INTERACTIVE_MODE           0
 #define USE_DQT_BARRIER            1
 #define INITIAL_DISPLAY_ENABLE     1
@@ -116 +138 @@
 unsigned int V_BEG[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
 unsigned int V_END[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
-unsigned int D_BEG[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
-unsigned int D_END[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
+unsigned int F_BEG[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
+unsigned int F_END[CLUSTERS_MAX][CORES_MAX] = {{ 0 }};
 
 // pointer on buffer containing the input image, maped by the main to the input file
@@ -128 +150 @@
 unsigned int THREAD_EXIT_SUCCESS = 0;
 unsigned int THREAD_EXIT_FAILURE = 1;
+
+// pointer and identifier for FBF windows 
+void   *  in_win_buf;
+int       in_wid;
+void   *  out_win_buf;
+int       out_wid;
 
 // synchronization barrier
@@ -137 +165 @@
 unsigned int  ncores;              // number of processors per cluster
 
+// main thread continuous index
+unsigned int     tid_main;
+
 // arrays of pointers on distributed buffers in all clusters
-unsigned short * GA[CLUSTERS_MAX];
+unsigned char  * GA[CLUSTERS_MAX];
 int            * GB[CLUSTERS_MAX];
 int            * GC[CLUSTERS_MAX];
@@ -153 +184 @@
 pthread_parallel_work_args_t exec_args[THREADS_MAX];
 
-// main thread continuous index
-unsigned int     tid_main;
+// image features
+unsigned int   image_nl;
+unsigned int   image_np;
+char           input_image_path[128];
+char           output_image_path[128];
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -166 +200 @@
 /////////////////
 void main( void )
+/////////////////
 {
     unsigned long long start_cycle;
@@ -222 +257 @@
     unsigned int nthreads  = nclusters * ncores;
 
+    // get input and output images pathnames and size
+    if( INTERACTIVE_MODE )
+    {
+        // get image size
+        printf("\n[convol] image nlines      : ");
+        get_uint32( &image_nl );
+
+        printf("\n[convol] image npixels     : ");
+        get_uint32( &image_np );
+
+        printf("\n[convol] input image path  : ");
+        get_string( input_image_path , 128 );
+
+        printf("[convol] output image path : ");
+        get_string( output_image_path , 128 );
+    }
+    else
+    {
+        image_nl = NL;
+        image_np = NP;
+        strcpy( input_image_path  , INPUT_IMAGE_PATH );
+        strcpy( output_image_path , OUTPUT_IMAGE_PATH );
+    }
+
     // main thread get FBF size and type
-    unsigned int   fbf_width;
-    unsigned int   fbf_height;
-    unsigned int   fbf_type;
+    int   fbf_width;
+    int   fbf_height;
+    int   fbf_type;
     fbf_get_config( &fbf_width , &fbf_height , &fbf_type );
 
-    if( (fbf_width != NP) || (fbf_height != NL) || (fbf_type != FBF_TYPE) )
-    {
-        printf("\n[convol error] image does not fit FBF size or type\n");
-        exit( 0 );
-    }
-
-    if( nthreads > NL )
-    {
-        printf("\n[convol error] number of threads larger than number of lines\n");
+    if( ((unsigned int)fbf_width  < image_np) || 
+        ((unsigned int)fbf_height < image_nl) || 
+        (fbf_type != IMAGE_TYPE) )
+    {
+        printf("\n[convol error] image not acceptable\n"
+               "FBF width  = %d / npixels  = %d\n"
+               "FBF height = %d / nlines   = %d\n"
+               "FBF type   = %d / expected = %d\n",
+               fbf_width, image_np, fbf_height, image_nl, fbf_type, IMAGE_TYPE );
+        exit( 0 );
+    }
+
+    if( nthreads > image_nl )
+    {
+        printf("\n[convol error] nthreads (%d] larger than nlines (%d)\n",
+        nthreads , image_nl );
         exit( 0 );
     }
@@ -248 +314 @@
         // build instrumentation file name
         if( USE_DQT_BARRIER )
-        snprintf( instru_name , 32 , "conv_dqt_no_place_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "dqt_no_place_%d_%d", x_size * y_size , ncores );
         else
-        snprintf( instru_name , 32 , "conv_smp_no_place_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "smp_no_place_%d_%d", x_size * y_size , ncores );
     }
 
@@ -260 +326 @@
         // build instrumentation file name
         if( USE_DQT_BARRIER )
-        snprintf( instru_name , 32 , "conv_dqt_explicit_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "dqt_explicit_%d_%d", x_size * y_size , ncores );
         else
-        snprintf( instru_name , 32 , "conv_smp_explicit_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "smp_explicit_%d_%d", x_size * y_size , ncores );
     }
 
@@ -272 +338 @@
         // build instrumentation file name
         if( USE_DQT_BARRIER )
-        snprintf( instru_name , 32 , "conv_dqt_parallel_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "dqt_parallel_%d_%d", x_size * y_size , ncores );
         else
-        snprintf( instru_name , 32 , "conv_smp_parallel_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "smp_parallel_%d_%d", x_size * y_size , ncores );
     }
 
     // open instrumentation file
-    snprintf( instru_path , 64 , "/home/%s", instru_name );
+    snprintf( instru_path , 64 , "/home/convol/%s", instru_name );
     FILE * f_instru = fopen( instru_path , NULL );
     if ( f_instru == NULL ) 
@@ -289 +355 @@
 printf("\n[convol] main on core[%x,%d] open instrumentation file %s\n",
 cxy_main, lid_main, instru_path );
+#endif
+
+    // main create an FBF window for input image
+    in_wid = fbf_create_window( 0,                   // l_zero
+                                0,                   // p_zero
+                                image_nl,            // lines
+                                image_np,            // pixels
+                                &in_win_buf );
+    if( in_wid < 0 ) 
+    {
+        printf("\n[transpose error] cannot open FBF window for %s\n",
+        input_image_path);
+        exit( 0 );
+    }
+
+    // activate window
+    error = fbf_active_window( in_wid , 1 );
+
+    if( error )
+    {
+        printf("\n[transpose error] cannot activate window for %s\n",
+        input_image_path );
+        exit( 0 );
+    }
+
+#if  VERBOSE_MAIN
+printf("\n[convol] main on core[%x,%d] created FBF window (wid %d) for <%s>\n",
+cxy_main, lid_main, in_wid, input_image_path );
+#endif
+
+    // main create an FBF window for output image
+    out_wid = fbf_create_window( 0,                   // l_zero
+                                 image_np,            // p_zero
+                                 image_nl,            // lines
+                                 image_np,            // pixels
+                                 &out_win_buf );
+    if( out_wid < 0 ) 
+    {
+        printf("\n[transpose error] cannot create FBF window for %s\n",
+        output_image_path);
+        exit( 0 );
+    }
+
+    // activate window
+    error = fbf_active_window( out_wid , 1 );
+
+    if( error )
+    {
+        printf("\n[transpose error] cannot activate window for %s\n",
+        output_image_path );
+        exit( 0 );
+    }
+
+#if  VERBOSE_MAIN
+printf("\n[convol] main on core[%x,%d] created FBF window (wid %d) for <%s>\n",
+cxy_main, lid_main, out_wid, output_image_path );
 #endif
 
@@ -312 +434 @@
 
 #if VERBOSE_MAIN
-printf("\n[convol] main on core[%x,%d] completes barrier init\n", 
+printf("\n[convol] main on core[%x,%d] completed barrier init\n", 
 cxy_main, lid_main );
 #endif
 
     // main open input file
-    int fd_in = open( IMAGE_IN_PATH , O_RDONLY , 0 );
+    int fd_in = open( input_image_path , O_RDONLY , 0 );
 
     if ( fd_in < 0 ) 
     { 
-        printf("\n[convol error] cannot open input file <%s>\n", IMAGE_IN_PATH );
-        exit( 0 );
-    }
-
-#if VERBOSE_MAIN
-printf("\n[convol] main on core[%x,%d] open file <%s>\n",
-cxy_main, lid_main, IMAGE_IN_PATH );
-#endif
-    
-    // main thread map image_in buffer to input file 
+        printf("\n[convol error] cannot open input file <%s>\n", input_image_path );
+        exit( 0 );
+    }
+
+    // main thread map input file to image_in buffer 
     image_in = (unsigned char *)mmap( NULL,
-                                      NB_PIXELS * IMAGE_IN_PIXEL_SIZE,
+                                      image_np * image_nl,
                                       PROT_READ,
                                       MAP_FILE | MAP_SHARED,
@@ -339 +456 @@
     if ( image_in == NULL ) 
     { 
-        printf("\n[convol error] main cannot map buffer to file %s\n", IMAGE_IN_PATH );
+        printf("\n[convol error] main cannot map buffer to file %s\n", input_image_path );
         exit( 0 );
     }
 
 #if  VERBOSE_MAIN
-printf("\n[convol] main on core[%x,%x] map buffer to file <%s>\n",
-cxy_main, lid_main, IMAGE_IN_PATH );
+printf("\n[convol] main on core[%x,%x] map <image_in> buffer to file <%s>\n",
+cxy_main, lid_main, input_image_path );
 #endif
 
     // main thread open output file
-    int fd_out = open( IMAGE_OUT_PATH , O_CREAT , 0 ); 
+    int fd_out = open( output_image_path , O_CREAT , 0 ); 
 
     if ( fd_out < 0 ) 
     { 
-        printf("\n[convol error] main cannot open file %s\n", IMAGE_OUT_PATH );
-        exit( 0 );
-    }
-
-#if  VERBOSE_MAIN
-printf("\n[convol] main on core[%x,%d] open file <%s>\n",
-cxy_main, lid_main, IMAGE_OUT_PATH );
-#endif
+        printf("\n[convol error] main cannot open file %s\n", output_image_path );
+        exit( 0 );
+    }
 
     // main thread map image_out buffer to output file
     image_out = (unsigned char *)mmap( NULL,
-                                       NB_PIXELS + IMAGE_OUT_PIXEL_SIZE,
+                                       image_np * image_nl,
                                        PROT_WRITE,
                                        MAP_FILE | MAP_SHARED,
@@ -371 +483 @@
     if ( image_out == NULL ) 
     { 
-        printf("\n[convol error] main cannot map buffer to file %s\n", IMAGE_OUT_PATH );
+        printf("\n[convol error] main cannot map buffer to file %s\n", output_image_path );
         exit( 0 );
     }
 
 #if  VERBOSE_MAIN
-printf("\n[convol] main on core[%x,%x] map buffer to file <%s>\n",
-cxy_main, lid_main, IMAGE_OUT_PATH );
+printf("\n[convol] main on core[%x,%x] map <image_out> buffer to file <%s>\n",
+cxy_main, lid_main, output_image_path );
 #endif
 
@@ -389 +501 @@
 {
     // the tid value for the main thread is always 0
-    // main thread creates new threads with tid in [1,nthreads-1]  
+    // main thread creates other threads with tid in [1,nthreads-1]  
     unsigned int tid;
     for ( tid = 0 ; tid < nthreads ; tid++ )
@@ -587 +699 @@
 #endif
 
+    // ask confirm for exit
+    if( INTERACTIVE_MODE )
+    {
+        char byte;
+        printf("\n[convol] press any key to to delete FBF windows and exit\n");
+        getc( &byte );
+    }
+  
+    // main thread delete FBF windows
+    fbf_delete_window( in_wid );
+    fbf_delete_window( out_wid );
+
+#if VERBOSE_MAIN 
+printf("\n[convol] main deleted FBF windows\n" );
+#endif
+
     // main thread suicide 
     exit( 0 );
@@ -597 +725 @@
 
 
+
+
+
+
 //////////////////////////////////
 void * execute( void * arguments )
-
+//////////////////////////////////
 {
     unsigned long long date;
@@ -628 +760 @@
     // thread [cid][lid] indexes, and the core coordinates [cxy][lpid]
 
-    // get thread abstract identifiers 
+    // get thread abstract identifiers[cid,lid]  from tid
     unsigned int tid = args->tid;
     unsigned int cid = tid / ncores;   
@@ -642 +774 @@
 #endif
 
-    // build total number of threads and clusters from global variables
+    // compute nthreads and nclusters from global variables
     unsigned int nclusters = x_size * y_size;
     unsigned int nthreads  = nclusters * ncores;
@@ -652 +784 @@
     unsigned int z;                 // vertical filter index 
 
-    unsigned int lines_per_thread   = NL / nthreads;
-    unsigned int lines_per_cluster  = NL / nclusters;
-    unsigned int pixels_per_thread  = NP / nthreads;
-    unsigned int pixels_per_cluster = NP / nclusters;
-
-    // compute number of pixels stored in one abstract cluster cid
-    unsigned int local_pixels = NL * NP / nclusters;        
-
-    unsigned int first, last;
+    unsigned int lines_per_thread   = image_nl / nthreads;
+    unsigned int lines_per_cluster  = image_nl / nclusters;
+    unsigned int pixels_per_thread  = image_np / nthreads;
+    unsigned int pixels_per_cluster = image_np / nclusters;
+
+    // compute number of pixels stored in one cluster 
+    unsigned int local_pixels = image_nl * image_np / nclusters;        
 
     get_cycle( &date );
     START[cid][lid] = (unsigned int)date;
 
-    // Each thread[cid][0] allocates 5 local buffers, 
+    // Each thread[cid][0] allocates 5 buffers local cluster cid 
     // and registers these 5 pointers in the global arrays
     if ( lid == 0 )
     {
-        GA[cid] = malloc( local_pixels * sizeof( unsigned short ) );
+        GA[cid] = malloc( local_pixels * sizeof( unsigned char ) );
         GB[cid] = malloc( local_pixels * sizeof( int ) );
         GC[cid] = malloc( local_pixels * sizeof( int ) );
@@ -675 +805 @@
         GZ[cid] = malloc( local_pixels * sizeof( unsigned char ) );
 
-        if( (GA[cid] == NULL) || (GB[cid] == NULL) || (GC[cid] == NULL) || 
-            (GD[cid] == NULL) || (GZ[cid] == NULL) )
+        if( (GA[cid] == NULL) || 
+            (GB[cid] == NULL) || 
+            (GC[cid] == NULL) || 
+            (GD[cid] == NULL) || 
+            (GZ[cid] == NULL) )
         {
             printf("\n[convol error] thread[%d] cannot allocate buf_in\n", tid );
@@ -684 +817 @@
 #if VERBOSE_EXEC
 get_cycle( &date );
-printf( "\n[convol] exec[%d] on core[%x,%d] allocated shared buffers / cycle %d\n"
+printf("\n[convol] exec[%d] on core[%x,%d] allocated shared buffers / cycle %d\n"
 " GA %x / GB %x / GC %x / GD %x / GZ %x\n",
 tid, cxy , lpid, (unsigned int)date, GA[cid], GB[cid], GC[cid], GD[cid], GZ[cid] );
@@ -694 +827 @@
     pthread_barrier_wait( &barrier );
 
-    // Each thread[cid,lid] allocate and initialise in its private stack 
+    // Each thread[tid] allocates and initialises in its private stack 
     // a copy of the arrays of pointers on the distributed buffers.
-    unsigned short * A[CLUSTERS_MAX];
+    unsigned char  * A[CLUSTERS_MAX];
     int            * B[CLUSTERS_MAX];
     int            * C[CLUSTERS_MAX];
@@ -711 +844 @@
     }
 
-    // Each thread[cid,0] access the file containing the input image, to load
-    // the local A[cid] buffer. Other threads are waiting on the barrier.
-    if ( lid==0 )
-    {
-        unsigned int size   = local_pixels * sizeof( unsigned short );
-        unsigned int offset = size * cid;
-
-        memcpy( A[cid],
-                image_in + offset,
-                size );
+    unsigned int npixels  = image_np * lines_per_thread;     // pixels moved by any thread
+    unsigned int g_offset = npixels * tid;             // offset in global buffer for tid
+    unsigned int l_offset = npixels * lid;             // offset in local buffer for tid
+
+    // min and max line indexes handled by thread[tid] for a global buffer
+    unsigned int global_lmin = tid * lines_per_thread;   
+    unsigned int global_lmax = global_lmin + lines_per_thread;  
+
+    // min and max line indexes handled by thread[tid] for a local buffer
+    unsigned int local_lmin  = lid * lines_per_thread;   
+    unsigned int local_lmax  = local_lmin + lines_per_thread;  
+
+    // pmin and pmax pixel indexes handled by thread[tid] in a column
+    unsigned int column_pmin = tid * pixels_per_thread;  
+    unsigned int column_pmax = column_pmin + pixels_per_thread; 
+
+    // Each thread[tid] copy npixels from image_in buffer to local A[cid] buffer
+    memcpy( A[cid]   + l_offset,
+            image_in + g_offset,
+            npixels );
  
 #if VERBOSE_EXEC
@@ -728 +871 @@
 #endif
 
-    }
-
-    // Optionnal parallel display of the initial image stored in A[c] buffers.
-    // Eah thread[cid,lid] displays (NL/nthreads) lines. 
-
+    // Optionnal parallel display for the initial image 
     if ( INITIAL_DISPLAY_ENABLE )
     {
-        unsigned int line;
-        unsigned int offset = lines_per_thread * lid;
-
-        for ( l = 0 ; l < lines_per_thread ; l++ )
-        {
-            line = offset + l;
-
-            // copy TA[cid] to TZ[cid]
-            for ( p = 0 ; p < NP ; p++ )
-            {
-                TZ(cid, line, p) = (unsigned char)(TA(cid, line, p) >> 8);
-            }
-
-            // display one line to frame buffer
-            if (fbf_write( &TZ(cid, line, 0),                     // first pixel in TZ
-                           NP,                                    // number of bytes
-                           NP*(l + (tid * lines_per_thread))))    // offset in FBF
-            {
-                printf("\n[convol error] in %s : thread[%d] cannot access FBF\n",
-                __FUNCTION__ , tid );
-                pthread_exit( &THREAD_EXIT_FAILURE );
-            }
+        // each thread[tid] copy npixels from A[cid] to in_win_buf buffer
+        memcpy( in_win_buf + g_offset,
+                A[cid]     + l_offset,
+                npixels );
+
+        // refresh the FBF window 
+        if( fbf_refresh_window( in_wid , global_lmin , global_lmax ) ) 
+        {
+            printf("\n[convol error] in %s : thread[%d] cannot access FBF\n",
+            __FUNCTION__ , tid );
+            pthread_exit( &THREAD_EXIT_FAILURE );
         }
 
@@ -771 +899 @@
     ////////////////////////////////////////////////////////////
     // parallel horizontal filter : 
-    // B <= convol(FH(A))
+    // B <= Transpose(FH(A))
     // D <= A - FH(A)
-    // Each thread computes (NL/nthreads) lines.
+    // Each thread computes (image_nl/nthreads) lines.
     // The image must be extended :
     // if (z<0)    TA(cid,l,z) == TA(cid,l,0)
-    // if (z>NP-1) TA(cid,l,z) == TA(cid,l,NP-1)
+    // if (z>image_np-1) TA(cid,l,z) == TA(cid,l,image_np-1)
     ////////////////////////////////////////////////////////////
 
@@ -782 +910 @@
     H_BEG[cid][lid] = (unsigned int)date;
 
-    // l = absolute line index / p = absolute pixel index  
-    // first & last define which lines are handled by a given thread
-
-    first = tid * lines_per_thread;
-    last  = first + lines_per_thread;
-
-    for (l = first; l < last; l++)
+    // l = global line index / p = absolute pixel index  
+
+    for (l = global_lmin; l < global_lmax; l++)
     {
         // src_c and src_l are the cluster index and the line index for A & D
@@ -814 +938 @@
             TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm;
         }
-        // second domain : from (hrange+1) to (NP-hrange-1)
-        for (p = hrange + 1; p < NP - hrange; p++)
+        // second domain : from (hrange+1) to (image_np-hrange-1)
+        for (p = hrange + 1; p < image_np - hrange; p++)
         {
             // dst_c and dst_p are the cluster index and the pixel index for B
@@ -825 +949 @@
             TD(src_c, src_l, p) = (int) TA(src_c, src_l, p) - sum_p / hnorm;
         }
-        // third domain : from (NP-hrange) to (NP-1)
-        for (p = NP - hrange; p < NP; p++)
+        // third domain : from (image_np-hrange) to (image_np-1)
+        for (p = image_np - hrange; p < image_np; p++)
         {
             // dst_c and dst_p are the cluster index and the pixel index for B
             int dst_c = p / pixels_per_cluster;
             int dst_p = p % pixels_per_cluster;
-            sum_p = sum_p + (int) TA(src_c, src_l, NP - 1) 
+            sum_p = sum_p + (int) TA(src_c, src_l, image_np - 1) 
                           - (int) TA(src_c, src_l, p - hrange - 1);
             TB(dst_c, dst_p, l) = sum_p / hnorm;
@@ -858 +982 @@
     ///////////////////////////////////////////////////////////////
     // parallel vertical filter : 
-    // C <= transpose(FV(B))
-    // Each thread computes (NP/nthreads) columns
+    // C <= Transpose(FV(B))
+    // Each thread computes (image_np/nthreads) columns
     // The image must be extended :
     // if (l<0)    TB(cid,p,l) == TB(cid,p,0)
-    // if (l>NL-1)   TB(cid,p,l) == TB(cid,p,NL-1)
+    // if (l>image_nl-1)   TB(cid,p,l) == TB(cid,p,image_nl-1)
     ///////////////////////////////////////////////////////////////
 
@@ -868 +992 @@
     V_BEG[cid][lid] = (unsigned int)date;
 
-    // l = absolute line index / p = absolute pixel index
-    // first & last define which pixels are handled by a given thread
-
-    first = tid * pixels_per_thread;
-    last  = first + pixels_per_thread;
-
-    for (p = first; p < last; p++)
+    // l = global line index / p = pixel index in column
+
+    for (p = column_pmin; p < column_pmax ; p++)
     {
         // src_c and src_p are the cluster index and the pixel index for B
@@ -883 +1003 @@
 
         // We use the specific values of the vertical ep-filter
-        // To minimize the number of tests, the NL lines are split in three domains 
+        // To minimize the number of tests, the image_nl lines are split in three domains 
 
         // first domain : explicit computation for the first 18 values
@@ -899 +1019 @@
         }
         // second domain
-        for (l = 18; l < NL - 17; l++)
+        for (l = 18; l < image_nl - 17; l++)
         {
             // dst_c and dst_l are the cluster index and the line index for C
@@ -919 +1039 @@
         }
         // third domain
-        for (l = NL - 17; l < NL; l++)
+        for (l = image_nl - 17; l < image_nl; l++)
         {
             // dst_c and dst_l are the cluster index and the line index for C
@@ -925 +1045 @@
             int dst_l = l % lines_per_cluster;
 
-            sum_l = sum_l + TB(src_c, src_p, min(l + 4, NL - 1))
-                  + TB(src_c, src_p, min(l + 8, NL - 1))
-                  + TB(src_c, src_p, min(l + 11, NL - 1))
-                  + TB(src_c, src_p, min(l + 15, NL - 1))
-                  + TB(src_c, src_p, min(l + 17, NL - 1))
+            sum_l = sum_l + TB(src_c, src_p, min(l + 4, image_nl - 1))
+                  + TB(src_c, src_p, min(l + 8, image_nl - 1))
+                  + TB(src_c, src_p, min(l + 11, image_nl - 1))
+                  + TB(src_c, src_p, min(l + 15, image_nl - 1))
+                  + TB(src_c, src_p, min(l + 17, image_nl - 1))
                   - TB(src_c, src_p, l - 5)
                   - TB(src_c, src_p, l - 9)
@@ -958 +1078 @@
     pthread_barrier_wait( &barrier );
 
-    // Optional parallel display of the final image Z <= D + C
-    // Eah thread[x,y,p] displays (NL/nthreads) lines.
-
+    ///////////////////////////////////////////////////////////////
+    // build final image in local Z buffer from C & D local buffers
+    // store it in output image file, and display it on FBF.
+    // Z <= C + D
+    ///////////////////////////////////////////////////////////////
+
+    get_cycle( &date );
+    F_BEG[cid][lid] = (unsigned int)date;
+
+    // Each thread[tid] set local buffer Z[cid] from local buffers C[cid] & D[cid]
+
+    for( l = local_lmin ; l < local_lmax ; l++ )
+    {
+        for( p = 0 ; p < image_np ; p++ )
+        {
+            TZ(cid,l,p) = TC(cid,l,p) + TD(cid,l,p);
+        }
+    }
+
+    // Each thread[tid] copy npixels from Z[cid] buffer to image_out buffer
+    memcpy( image_out + g_offset,
+            Z[cid]    + l_offset,
+            npixels );
+
+    // Optional parallel display of the final image 
     if ( FINAL_DISPLAY_ENABLE )
     {
-        get_cycle( &date );
-        D_BEG[cid][lid] = (unsigned int)date;
-
-        unsigned int line;
-        unsigned int offset = lines_per_thread * lid;
-
-        for ( l = 0 ; l < lines_per_thread ; l++ )
-        {
-            line = offset + l;
-
-            for ( p = 0 ; p < NP ; p++ )
-            {
-                TZ(cid, line, p) = 
-                   (unsigned char)( (TD(cid, line, p) + 
-                                     TC(cid, line, p) ) >> 8 );
-            }
-
-            if (fbf_write( &TZ(cid, line, 0),                   // first pixel in TZ
-                           NP,                                  // number of bytes
-                           NP*(l + (tid * lines_per_thread))))  // offset in FBF
-            {
-                printf("\n[convol error] thread[%d] cannot access FBF\n", tid );
-                pthread_exit( &THREAD_EXIT_FAILURE );
-            }
-        }
-
-        get_cycle( &date );
-        D_END[cid][lid] = (unsigned int)date;
-
-#if VERBOSE_EXEC
+        // each thread[tid] copy npixels from Z[cid] to out_win_buf buffer
+        memcpy( out_win_buf + g_offset,
+                Z[cid]      + l_offset,
+                npixels );
+
+        // refresh the FBF window 
+        if( fbf_refresh_window( out_wid , global_lmin , global_lmax ) )
+        {
+            printf("\n[convol error] in %s : thread[%d] cannot access FBF\n",
+            __FUNCTION__ , tid );
+            pthread_exit( &THREAD_EXIT_FAILURE );
+        }
+
+#if VERBOSE_EXEC 
 get_cycle( &date );
 printf( "\n[convol] exec[%d] on core[%x,%d] completed final display / cycle %d\n",
-tid , cxy , lid , (unsigned int)date );
+tid , cxy , lpid , (unsigned int)date );
 #endif
 
@@ -1010 +1136 @@
     }
 
+    get_cycle( &date );
+    F_END[cid][lid] = (unsigned int)date;
+
     // thread termination depends on the placement policy
     if( PARALLEL_PLACEMENT )   
@@ -1031 +1160 @@
 
 } // end execute()
+
+
+
 
 
@@ -1057 +1189 @@
     unsigned int max_v_end = 0;
 
-    unsigned int min_d_beg = 0xFFFFFFFF;
-    unsigned int max_d_beg = 0;
-
-    unsigned int min_d_end = 0xFFFFFFFF;
-    unsigned int max_d_end = 0;
+    unsigned int min_f_beg = 0xFFFFFFFF;
+    unsigned int max_f_beg = 0;
+
+    unsigned int min_f_end = 0xFFFFFFFF;
+    unsigned int max_f_end = 0;
 
     for (cc = 0; cc < nclusters; cc++)
@@ -1082 +1214 @@
             if (V_END[cc][pp] > max_v_end) max_v_end = V_END[cc][pp];
 
-            if (D_BEG[cc][pp] < min_d_beg) min_d_beg = D_BEG[cc][pp];
-            if (D_BEG[cc][pp] > max_d_beg) max_d_beg = D_BEG[cc][pp];
-
-            if (D_END[cc][pp] < min_d_end) min_d_end = D_END[cc][pp];
-            if (D_END[cc][pp] > max_d_end) max_d_end = D_END[cc][pp];
+            if (F_BEG[cc][pp] < min_f_beg) min_f_beg = F_BEG[cc][pp];
+            if (F_BEG[cc][pp] > max_f_beg) max_f_beg = F_BEG[cc][pp];
+
+            if (F_END[cc][pp] < min_f_end) min_f_end = F_END[cc][pp];
+            if (F_END[cc][pp] > max_f_end) max_f_end = F_END[cc][pp];
         }
     }
@@ -1109 +1241 @@
 
     printf(" - D_BEG : min = %d / max = %d / med = %d / delta = %d\n",
-           min_d_beg, max_d_beg, (min_d_beg+max_d_beg)/2, max_d_beg-min_d_beg);
+           min_f_beg, max_f_beg, (min_f_beg+max_f_beg)/2, max_f_beg-min_f_beg);
 
     printf(" - D_END : min = %d / max = %d / med = %d / delta = %d\n",
-           min_d_end, max_d_end, (min_d_end+max_d_end)/2, max_d_end-min_d_end);
+           min_f_end, max_f_end, (min_f_end+max_f_end)/2, max_f_end-min_f_end);
 
     printf( "\n General Scenario   (Kcycles)\n" );
@@ -1119 +1251 @@
     printf( " - BARRIER HORI/VERT = %d\n", (min_v_beg - max_h_end)/1000 );
     printf( " - V_FILTER          = %d\n", (max_v_end - min_v_beg)/1000 );
-    printf( " - BARRIER VERT/DISP = %d\n", (min_d_beg - max_v_end)/1000 );
-    printf( " - DISPLAY           = %d\n", (max_d_end - min_d_beg)/1000 );
+    printf( " - BARRIER VERT/DISP = %d\n", (min_f_beg - max_v_end)/1000 );
+    printf( " - DISPLAY           = %d\n", (max_f_end - min_f_beg)/1000 );
     printf( " \nSEQUENCIAL = %d / PARALLEL = %d\n",
             SEQUENCIAL_TIME/1000, PARALLEL_TIME/1000 );
@@ -1143 +1275 @@
 
     fprintf( f , " - D_BEG : min = %d / max = %d / med = %d / delta = %d\n",
-           min_d_beg, max_d_beg, (min_d_beg+max_d_beg)/2, max_d_beg-min_d_beg);
+           min_f_beg, max_f_beg, (min_f_beg+max_f_beg)/2, max_f_beg-min_f_beg);
 
     fprintf( f , " - D_END : min = %d / max = %d / med = %d / delta = %d\n",
-           min_d_end, max_d_end, (min_d_end+max_d_end)/2, max_d_end-min_d_end);
+           min_f_end, max_f_end, (min_f_end+max_f_end)/2, max_f_end-min_f_end);
 
     fprintf( f ,  "\n General Scenario (Kcycles)\n" );
@@ -1153 +1285 @@
     fprintf( f ,  " - BARRIER HORI/VERT = %d\n", (min_v_beg - max_h_end)/1000 );
     fprintf( f ,  " - V_FILTER          = %d\n", (max_v_end - min_v_beg)/1000 );
-    fprintf( f ,  " - BARRIER VERT/DISP = %d\n", (min_d_beg - max_v_end)/1000 );
-    fprintf( f ,  " - DISPLAY           = %d\n", (max_d_end - min_d_beg)/1000 );
+    fprintf( f ,  " - BARRIER VERT/DISP = %d\n", (min_f_beg - max_v_end)/1000 );
+    fprintf( f ,  " - SAVE              = %d\n", (max_f_end - min_f_beg)/1000 );
     fprintf( f ,  " \nSEQUENCIAL = %d / PARALLEL = %d\n",
     SEQUENCIAL_TIME/1000, PARALLEL_TIME/1000 );

trunk/user/display/display.c

@@ -4 +4 @@
 //  author : Alain Greiner
 ///////////////////////////////////////////////////////////////////////////////////////
-//  This file describes the single thread "display" application.
-//  It uses the external chained buffer DMA to display a stream
-//  of images on the frame buffer.  
+//  This file describes the single thread "display" application that simply
+//  open a file containing a raw image stored on disk, ans distplay it on the
+//  Frame Buffer without using the ALMOS-MKH windows manager.
 ///////////////////////////////////////////////////////////////////////////////////////
 
@@ -15 +15 @@
 #include <almosmkh.h>
 
-#define PATH_MAX_LENGHT    128
+#define PATH_NAME   "misc/images_128.ram"
 
 #define FBF_TYPE    420         
@@ -80 +80 @@
     }
 
+    // check pixel encoding type
     if( fbf_type != FBF_TYPE )
     {
@@ -87 +88 @@
     }
 
-    // get pathname for input file 
-    while( 1 )
-    {
-        printf("\n[display] path = ");
-
-        error = get_string( pathname , PATH_MAX_LENGHT );
-
-        if ( error )  printf("\n[display error] cannot get path for input file\n" );
-        else  break;
-    }
-
     // open file
-    int fd = open( pathname , O_RDONLY , 0 );
-
+    int fd = open( PATH_NAME , O_RDONLY , 0 );
     if( fd < 0 )
     {

trunk/user/init/init.c

@@ -20 +20 @@
 #include <shared_syscalls.h>
 
-#define DEBUG_PROCESS_INIT    1
+#define DEBUG_PROCESS_INIT    0
 
 ////////////////
@@ -36 +36 @@
 #endif
 
-    // get Number of TXT channels from hard configuration
+    // get number of TXT channels from hard configuration
     hard_config_t config;      
+
     get_config( &config );
 
     unsigned int  txt_channels = config.txt_channels;
-    unsigned int  x_size       = config.x_size;
-    unsigned int  y_size       = config.y_size;
-    unsigned int  ncores       = config.ncores;
 
     // check number of TXT channels
@@ -49 +47 @@
     {
         snprintf( string , 64 ,
-        "\n[init ERROR] number of TXT channels must be larger than 1\n");
+        "\n[init ERROR] number of TXT channels must be larger than 1");
         display_string( string );
         exit( EXIT_FAILURE );
@@ -64 +62 @@
             // INIT display error message  
             snprintf( string , 64 , 
-            "[init ERROR] cannot fork child[%d] => suicide" , i );
+            "\n[init ERROR] cannot fork child[%d] => suicide" , i );
             display_string( string );
 
@@ -72 +70 @@
         else if( ret_fork == 0 )                    // we are in CHILD[i] process
         {
+
+#if DEBUG_PROCESS_INIT
+            snprintf( string , 64 ,
+            "\n[init] CHILD[%d] process forked / call execve", i );
+            display_string( string );
+#endif
             // CHILD[i] process exec process KSH[i]
             ret_exec = execve( "/bin/user/ksh.elf" , NULL , NULL ); 
@@ -79 +83 @@
                 // CHILD[i] display error message
                 snprintf( string , 64 , 
-                "[init ERROR] CHILD[%d] cannot exec KSH / ret_exec = %d" , i , ret_exec );
+                "\n[init ERROR] CHILD[%d] cannot exec KSH" , i );
                 display_string( string );
 
@@ -90 +94 @@
             // INIT display CHILD[i] process PID
             snprintf( string , 64 ,
-            "[init] (pid 0x1) created ksh[%d] (pid %x)", i , ret_fork ); 
+            "\n[init] (pid 0x1) create ksh[%d] (pid %x)", i , ret_fork ); 
             display_string( string );
 
@@ -104 +108 @@
     unsigned int  cxy;           // cluster identifier
     unsigned int  lid;           // core local index
+
+    unsigned int  x_size       = config.x_size;
+    unsigned int  y_size       = config.y_size;
+    unsigned int  ncores       = config.ncores;
 
     // INIT displays processes and threads in all clusters

trunk/user/kleenex/kleenex.c

@@ -19 +19 @@
 #include <almosmkh.h>
 
-#define IN_FILENAME     "misc/philips_1024_2.raw"
-#define OUT_FILENAME    "misc/philips_1024.raw"
+#define IN_FILENAME     "misc/philips_1024.raw"
+#define OUT_FILENAME    "misc/philips_1024.new"
 #define FBF_TYPE        420         
 #define NPIXELS         1024
@@ -31 +31 @@
     int                fd_out;
 
-    unsigned int       fbf_width;
-    unsigned int       fbf_height;
-    unsigned int       fbf_type;
+    int                fbf_width;
+    int                fbf_height;
+    int                fbf_type;
 
     int                line;
@@ -42 +42 @@
     unsigned long long start_cycle;
 
-    unsigned short     buf_in[NPIXELS * NLINES * 2];
-//    unsigned char      buf_in[NPIXELS * NLINES];
+    unsigned char      buf_in[NPIXELS * NLINES];
     unsigned char      buf_out[NPIXELS * NLINES];
 
     struct stat        st;
 
-    int                size_in  = NPIXELS * NLINES * 2;
-//    int                size_in  = NPIXELS * NLINES;
+    int                size_in  = NPIXELS * NLINES;
     int                size_out = NPIXELS * NLINES;
 
@@ -111 +109 @@
         {
             unsigned int index = (line*NPIXELS) + pixel;
-            buf_out[index] = (unsigned char)(buf_in[index]>>8);
-//            buf_out[index] = buf_in[index];
+            buf_out[index] = buf_in[index];
         }
     }

trunk/user/ksh/ksh.c

@@ -58 +58 @@
 
 #define DEBUG_MAIN          0
-#define DEBUG_INTER         0
 #define DEBUG_EXECUTE       0
 #define DEBUG_CMD_CAT       0
@@ -105 +104 @@
 pthread_t       trdid;                      // interactive thread identifier
 
+char            cmd[CMD_MAX_SIZE];                  // buffer for one command
+
+char            elf_path[PATH_MAX_SIZE];    // pathname for cmd_load command
+
 char            pathname[PATH_MAX_SIZE];    // pathname for a file
 
-char            pathnew[PATH_MAX_SIZE];     // used by the rename command
+char            pathnew[PATH_MAX_SIZE];     // used by the cmd_rename command
  
-char            string[128];                // used by snprintf() for debug
+char            string[256];                // used by snprintf() for debug
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -124 +127 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s enters" , __FUNCTION__);
-display_string( string );
+printf("\n[ksh] %s enters" , __FUNCTION__);
 #endif
 
@@ -139 +141 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s : after strcpy" , __FUNCTION__ );
-display_string( string );
+printf("\n[ksh] %s : after strcpy" , __FUNCTION__ );
 #endif
 
@@ -154 +155 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s : file %s open", __FUNCTION__, pathname );
-display_string( string );
+printf("\n[ksh] %s : file %s open", __FUNCTION__, pathname );
 #endif
 
@@ -181 +181 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s : size = %d",
-__FUNCTION__, size );
-display_string( string );
+printf("\n[ksh] %s : size = %d", __FUNCTION__, size );
 #endif
 
@@ -208 +206 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s : mapped file %d to buffer %x",
-__FUNCTION__, fd , buf );
-display_string( string );
+printf("\n[ksh] %s : mapped file %d to buffer %x", __FUNCTION__, fd , buf );
 #endif
 
@@ -223 +219 @@
 
 #if DEBUG_CMD_CAT
-snprintf( string , 128 , "[ksh] %s : unmapped file %d from buffer %x", 
-__FUNCTION__, fd , buf );
-display_string( string );
+printf("\n[ksh] %s : unmapped file %d from buffer %x", __FUNCTION__, fd , buf );
 #endif
 
@@ -273 +267 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] enter %s" , __FUNCTION__);
-display_string( string );
+printf("\n[ksh] enter %s" , __FUNCTION__);
 #endif
 
@@ -297 +290 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : file %s open", __FUNCTION__, argv[1] );
-display_string( string );
+printf("\n[ksh] %s : file %s open", __FUNCTION__, argv[1] );
 #endif
 
@@ -310 +302 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : got stats for %s", __FUNCTION__, argv[1] );
-display_string( string );
+printf("\n[ksh] %s : got stats for %s", __FUNCTION__, argv[1] );
 #endif
 
@@ -335 +326 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : file %s open", __FUNCTION__, argv[2] );
-display_string( string );
+printf("\n[ksh] %s : file %s open", __FUNCTION__, argv[2] );
 #endif
 
@@ -346 +336 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : got stats for %s", __FUNCTION__, argv[2] );
-display_string( string );
+printf("\n[ksh] %s : got stats for %s", __FUNCTION__, argv[2] );
 #endif
 
@@ -370 +359 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : read %d bytes from %s", __FUNCTION__, len, argv[1] );
-display_string( string );
+printf("\n[ksh] %s : read %d bytes from %s", __FUNCTION__, len, argv[1] );
 #endif
 
@@ -382 +370 @@
 
 #if DEBUG_CMD_CP
-snprintf( string , 128 , "[ksh] %s : write %d bytes to %s", __FUNCTION__, len, argv[2] );
-display_string( string );
+printf("\n[ksh] %s : write %d bytes to %s", __FUNCTION__, len, argv[2] );
 #endif
 
@@ -416 +403 @@
                "         display  fat      min      nslots\n"
                "         display  fat      cxy      0\n"
-               "         display  socket   pid      fdid\n" );
+               "         display  socket   pid      fdid\n" 
+               "         display  fd       pid\n"
+               "         display  fbf      pid\n" );
     }
     ////////////////////////////////////
@@ -578 +567 @@
         }
     }
-    ///////////////////////////////////////////
+    /////////////////////////////////////////
     else if( strcmp( argv[1] , "fat" ) == 0 )
     {
@@ -596 +585 @@
         }
     }
-    ///////////////////////////////////////////
+    ////////////////////////////////////////////
     else if( strcmp( argv[1] , "socket" ) == 0 )
     {
@@ -614 +603 @@
         }
     }
+    ////////////////////////////////////////
+    else if( strcmp( argv[1] , "fd" ) == 0 ) 
+    {
+        if( argc != 3 )
+        {
+                    printf("  usage: display fd pid\n");
+            }
+        else
+        {
+            unsigned int pid = atoi(argv[2]);
+            
+            if( display_fd_array( pid ) )
+            {
+                printf("  error: cannot found process %x\n", pid );
+            }
+        }
+    }
+    ////////////////////////////////////////
+    else if( strcmp( argv[1] , "fbf" ) == 0 ) 
+    {
+        if( argc != 3 )
+        {
+                    printf("  usage: display fbf pid\n"
+                   "         display fbf 0 (all processes)");
+            }
+        else
+        {
+            unsigned int pid = atoi(argv[2]);
+            
+            if( display_fbf_windows( pid ) )
+            {
+                printf("  error: cannot found process %x\n", pid );
+            }
+        }
+    }
     ////
     else
@@ -632 +656 @@
         if (argc != 2) 
     {
-                printf("  usage: %s pid\n", argv[0]);
+                printf("  usage: fg pid\n");
         }
     else
@@ -658 +682 @@
         unsigned int i;
 
-        if (argc != 1) 
-    {
-                printf("  usage: %s\n", argv[0]);
+        if( (argc != 1) || (argv[0] == NULL) ) 
+    {
+                printf("  usage: help\n");
         }
     else
@@ -676 +700 @@
 }   // end cmd_help()
 
+/////////////////////////////////////////////////
+static void cmd_history( int argc , char **argv )
+{
+        unsigned int i;
+
+        if( (argc != 1) || (argv[0] == NULL) ) 
+    {
+                printf("  usage: history\n"); 
+        }
+    else
+    {
+            printf("--- registered commands ---\n");
+            for (i = 0; i < LOG_DEPTH; i++) 
+        {
+                    printf(" - %d\t: %s\n", i, &log_entries[i].buf);
+            }
+    }
+
+    // release semaphore to get next command
+    sem_post( &semaphore );
+
+} // end cmd_history()
+
 //////////////////////////////////////////////
 static void cmd_kill( int argc , char **argv )
@@ -683 +730 @@
         if (argc != 2) 
     {
-                printf("  usage: %s pid\n", argv[0]);
+                printf("  usage: kill pid\n", argv[0]);
         }
     else
@@ -710 +757 @@
         int                  ret_fork;           // return value from fork 
         int                  ret_exec;           // return value from exec
-    unsigned int         ksh_pid;            // KSH process PID
+    unsigned int         cmd_ok;             // command arguments acceptable
     unsigned int         background;         // background execution if non zero
-    unsigned int         placement;          // placement specified if non zero
-    unsigned int         cxy;                // target cluster if placement specified
+    unsigned int         place;              // user placement if non zero
+    char               * arg[5];             // array of pointers on main thread arguments
+    unsigned int         args_nr;            // number of aruments in this array
+
+    char                 undef[] = { "undefined" };
+
+    // arguments analysis of argv[] array that contains at most 8 strings:
+    // - the two first arguments ("cmd_type" & "elf_path") are mandatory 
+    // - the six next ("-pcxy","arg0","arg1","arg2","arg3","&") are optional
+
+     // analyse the optional arguments 
+    if( argc == 2 )                            // no optional arguments
+    {
+        cmd_ok     = 1;
+        background = 0;
+        place      = 0;
+        arg[0]     = undef;
+        arg[1]     = undef;
+        arg[2]     = undef;
+        arg[3]     = undef;
+        args_nr    = 0;
+    }
+    else if( ((argc >= 4) && (argc <= 8)) &&
+             (argv[2][0] == '-') && (argv[2][1] == 'p') &&           
+             (strcmp(argv[argc-1] , "&" ) == 0) )     // background, place, 0 to 4 args
+    {
+        cmd_ok     = 1;
+        background = 1;
+        place      = 0xFF000000 | atoi( argv[2] + 2 );
+        arg[0]     = (argc > 4) ? argv[3] : undef;
+        arg[1]     = (argc > 5) ? argv[4] : undef;
+        arg[2]     = (argc > 6) ? argv[5] : undef;
+        arg[3]     = (argc > 7) ? argv[6] : undef;
+        args_nr    = argc - 4;
+    }
+    else if( ((argc >= 3) && (argc <= 7)) &&
+             (argv[2][0] == '-') && (argv[2][1] == 'p') && 
+             (strcmp(argv[argc-1] , "&" ) != 0) )     // place, no background, 0 to 4 args
+    {
+        cmd_ok     = 1;
+        background = 0;
+        place      = 0xFF000000 | atoi( argv[2] + 2 );
+        arg[0]     = (argc > 3) ? argv[3] : undef;
+        arg[1]     = (argc > 4) ? argv[4] : undef;
+        arg[2]     = (argc > 5) ? argv[5] : undef;
+        arg[3]     = (argc > 6) ? argv[6] : undef;
+        args_nr    = argc - 3;
+    }
+    else if( ((argc >=3) && (argc <= 7))  &&       
+             ((argv[2][0] != '-') || (argv[2][1] != 'p')) && 
+             (strcmp(argv[argc-1] , "&" ) == 0) )     // no place, background, 0 to 4 args
+    {
+        cmd_ok     = 1;
+        background = 1;
+        place      = 0;
+        arg[0]     = (argc > 3) ? argv[2] : undef;
+        arg[1]     = (argc > 4) ? argv[3] : undef;
+        arg[2]     = (argc > 5) ? argv[4] : undef;
+        arg[3]     = (argc > 6) ? argv[5] : undef;
+        args_nr    = argc - 3;
+    }
+    else if( (argc >= 3) && (argc <= 6 ) )     // no place, no background, 0 to 4 args
+    {
+        cmd_ok     = 1;
+        background = 0;
+        place      = 0;
+        arg[0]     = (argc > 2) ? argv[2] : undef;
+        arg[1]     = (argc > 3) ? argv[3] : undef;
+        arg[2]     = (argc > 4) ? argv[4] : undef;
+        arg[3]     = (argc > 5) ? argv[5] : undef;
+        args_nr    = argc - 2;
+    }
+    else                                    // illegal optional arguments
+    {
+        cmd_ok = 0;
+        background = 0;
+        place      = 0;
+        arg[0]     = undef;
+        arg[1]     = undef;
+        arg[2]     = undef;
+        arg[3]     = undef;
+        args_nr    = 0;
+    }
+
+    // check syntax errors
+    if( cmd_ok == 0 )
+    {
+        printf("  usage: load elf_path [-pcxy] [arg0] [arg1] [arg2] [arg3] [&]\n");
+
+        // release semaphore to get next command
+        sem_post( &semaphore );
+
+        return;
+    }
+
+    // get elf_path
+    strcpy( elf_path , argv[1] );
 
 #if DEBUG_CMD_LOAD
-snprintf( string , 128 , "[ksh] enter %s" , __FUNCTION__);
-display_string( string );
-#endif
-
-        if( (argc < 2) || (argc > 4) )  
-    {
-                printf("  usage: %s pathname [cxy] [&]\n", argv[0] );
-        }
-    else
-    {
-            strcpy( pathname , argv[1] );
-
-        if( argc == 2 )
-        {
-            background = 0;
-            placement  = 0;
-            cxy        = 0;
-        }
-        else if( argc == 3 )
-        {
-            if( (argv[2][0] == '&') && (argv[2][1] == 0) )
-            {
-                background = 1;
-                placement  = 0;
-                cxy        = 0;
-            }
-            else 
-            {
-                background = 0;
-                placement  = 1;
-                cxy        = atoi( argv[2] );
-            }
-        }
-        else  // argc == 4
-        { 
-            background = ( (argv[3][0] == '&') && (argv[3][1] == 0) );
-            placement  = 1;
-            cxy        = atoi( argv[2] );
-        }
-
-        // get KSH process PID
-        ksh_pid = getpid();
+printf("\n[ksh] %s : path <%s> / place %x / args_nr %d / bg %d\n"
+"                 arg0 %s / arg1 %s / arg2 %s / arg3 %s\n",
+__FUNCTION__, elf_path , place , args_nr , background , arg[0] , arg[1] , arg[2] , arg[3] );
+#endif
+
+    // set NULL pointers in args[] array
+    if     ( arg[0] == undef ) arg[0] = NULL;
+    else if( arg[1] == undef ) arg[1] = NULL;
+    else if( arg[2] == undef ) arg[2] = NULL;
+    else if( arg[3] == undef ) arg[3] = NULL;
+    else                       arg[4] = NULL;
+
+    // set target cluster if required
+    if( place ) place_fork( place & 0xFFFF );
+
+    // KSH process fork CHILD process
+        ret_fork = fork();
+
+    if ( ret_fork < 0 )     // it is a failure reported to KSH
+    {
+        printf("  error: ksh process unable to fork\n");
+    }
+    else if (ret_fork == 0) // it is the CHILD process 
+    {
 
 #if DEBUG_CMD_LOAD
-snprintf( string , 128 , "[ksh] %s : <%s> / bg %d / place %d / cxy %x",
-__FUNCTION__, argv[1], background, placement, cxy );
-display_string( string );
-#endif
-
-        // set target cluster if required
-        if( placement ) place_fork( cxy );
-
-        // KSH process fork CHILD process
-            ret_fork = fork();
-
-        if ( ret_fork < 0 )     // it is a failure reported to KSH
-        {
-            printf("  error: ksh process unable to fork\n");
-        }
-        else if (ret_fork == 0) // it is the CHILD process 
-        {
+printf("\n[ksh] %s : child (pid %x) after fork, before exec\n",
+ __FUNCTION__ , getpid() );
+#endif
+
+        // CHILD process exec NEW process
+        ret_exec = execve( elf_path , arg , NULL );
 
 #if DEBUG_CMD_LOAD
-snprintf( string , 128 , "[ksh] %s : child (%x) after fork, before exec",
-__FUNCTION__ , getpid() );
-display_string( string );
-#endif
-
-            // CHILD process exec NEW process
-            ret_exec = execve( pathname , NULL , NULL );
+printf("\n[ksh] %s : child (pid %x) after exec / ret_exec %x\n",
+ __FUNCTION__, getpid(), ret_exec );
+#endif
+
+        // this is only executed in case of exec failure
+        if( ret_exec )
+        {
+            printf("  error: child process unable to exec <%s>\n", pathname );
+            exit( 0 );
+        }   
+        } 
+    else                    // it is the KSH process : ret_fork is the new process PID
+    {
 
 #if DEBUG_CMD_LOAD
-snprintf( string , 128 , "[ksh] %s : child (%x) after exec / ret_exec %x",
-__FUNCTION__ , getpid(), ret_exec );
-display_string( string );
-#endif
-
-            // this is only executed in case of exec failure
-            if( ret_exec )
-            {
-                printf("  error: child process unable to exec <%s>\n", pathname );
-                exit( 0 );
-            }   
-            } 
-        else                    // it is the KSH process : ret_fork is the new process PID
-        {
-
-#if DEBUG_CMD_LOAD
-snprintf( string , 128 , "[ksh] %s : ksh (%x) after fork / ret_fork %x",
-__FUNCTION__, getpid(), ret_fork );
-display_string( string );
-#endif
-            // when the new process is launched in background, the KSH process 
-            // takes the TXT ownership, and release the semaphore to get the next command.
-            // Otherwise, the child process keep the TXT ownership, and the semaphore will
-            // be released by the KSH main thread when the child process exit
-
-            if( background )    //  KSH must keep TXT ownership
-            {
-                // get back the TXT ownership
-                fg( ksh_pid );
-
-                // release semaphore to get next command
-                sem_post( &semaphore );
-            }
+printf("\n[ksh] %s : ksh (pid %x) after fork / ret_fork %x\n",
+ __FUNCTION__, getpid(), ret_fork );
+#endif
+        // when the new process is launched in background, the KSH process 
+        // takes the TXT ownership, and releases the semaphore to get the next command.
+        // Otherwise, the child process keep the TXT ownership, and the semaphore will
+        // be released by the KSH main thread when the child process exit
+
+        if( background )    //  KSH must keep TXT ownership
+        {
+            // KSH get back the TXT ownership
+            fg( getpid() );
+
+            // release semaphore to get next command
+            sem_post( &semaphore );
         }
     }
 }   // end cmd_load
-
-/////////////////////////////////////////////
-static void cmd_log( int argc , char **argv )
-{
-        unsigned int i;
-
-        if (argc != 1)
-    {
-                printf("  usage: %s\n", argv[0], argc ); 
-        }
-    else
-    {
-            printf("--- registered commands ---\n");
-            for (i = 0; i < LOG_DEPTH; i++) 
-        {
-                    printf(" - %d\t: %s\n", i, &log_entries[i].buf);
-            }
-    }
-
-    // release semaphore to get next command
-    sem_post( &semaphore );
-
-} // end cmd_log()
-
 
 ////////////////////////////////////////////
@@ -856 +933 @@
 
 #if DEBUG_CMD_LS
-snprintf( string , 128 , "[ksh] enter %s" , __FUNCTION__);
-display_string( string );
+printf("\n[ksh] enter %s" , __FUNCTION__);
 #endif
 
@@ -876 +952 @@
 
 #if DEBUG_CMD_LS
-snprintf( string , 128 , "[ksh] %s : directory <%s> open / DIR %x",
-__FUNCTION__, pathname , dir );
-display_string( string );
+printf("\n[ksh] %s : directory <%s> open / DIR %x", __FUNCTION__, pathname , dir );
 #endif
 
@@ -899 +973 @@
 
 #if DEBUG_CMD_LS
-snprintf( string , 128 , "[ksh] %s : directory <%s> closed",
-__FUNCTION__, pathname );
-display_string( string );
+printf("\n[ksh] %s : directory <%s> closed", __FUNCTION__, pathname );
 #endif
 
@@ -964 +1036 @@
 
 #if DEBUG_CMD_PS
-snprintf( string , 128 , "[ksh] enter %s" , __FUNCTION__);
-display_string( string );
-#endif
-
-        if (argc != 1)
-    {
-                printf("  usage: %s\n", argv[0]);
+printf("\n[ksh] enter %s" , __FUNCTION__);
+#endif
+
+        if( (argc != 1) || (argv[0] == NULL) ) 
+    {
+                printf("  usage: ps\n");
         }
     else
@@ -987 +1058 @@
 
 #if DEBUG_CMD_PS
-snprintf( string , 128 , "\n[ksh] %s : call display_cluster_process()", __FUNCTION__ );
-display_string( string );
+printf("\n[ksh] %s : call display_cluster_process()", __FUNCTION__ );
 #endif
 
@@ -1005 +1075 @@
 static void cmd_pwd( int argc , char **argv )
 {
-        if (argc != 1)
-    {
-                printf("  usage: %s\n", argv[0]);
+        if( (argc != 1) || (argv[0] == NULL) ) 
+    {
+                printf("  usage: pwd\n");
         }
     else 
@@ -1031 +1101 @@
         if (argc != 2)
     {
-                printf("  usage: %s pathname\n", argv[0]);
+                printf("  usage: rm pathname\n");
         }
     else
@@ -1056 +1126 @@
         if (argc != 2)
     {
-                printf("  usage: %s pathname\n", argv[0]);
+                printf("  usage: stat pathname\n");
         }
     else
@@ -1084 +1154 @@
 static void cmd_rmdir( int argc , char **argv )
 {
-    // same as cmd_rm()
-        cmd_rm (argc , argv );
-}
+        if (argc != 2)
+    {
+                printf("  usage: rmdir pathname\n");
+        }
+    else
+    {
+            strcpy( pathname , argv[1] );
+
+        if ( unlink( pathname ) )
+        {
+                    printf("  error: unable to remove <%s>\n", pathname );
+            }
+    }
+
+    // release semaphore to get next command
+    sem_post( &semaphore );
+
+}  // end cmd_rmdir()
 
 ///////////////////////////////////////////////
@@ -1153 +1238 @@
         { "load",    "load an user application",                        cmd_load    },
         { "help",    "list available commands",                         cmd_help    },
+        { "history", "list registered commands",                        cmd_history },
         { "kill",    "kill a process (all threads)",                    cmd_kill    },
-        { "log",     "list registered commands",                        cmd_log     },
         { "ls",      "list directory entries",                          cmd_ls      },
         { "mkdir",   "create a new directory",                          cmd_mkdir   },
@@ -1179 +1264 @@
 
 #if DEBUG_EXECUTE
-snprintf( string , 128 , "[ksh] enter %s for command <%s>" , __FUNCTION__ , buf );
-display_string( string );
-#endif
-
-        // build argc/argv
+printf("\n[ksh] enter %s for command <%s>" , __FUNCTION__ , buf );
+#endif
+
+        // build argc/argv : 
+    // arg[0] is the command type
+    // - other arg[i] are the command arguments 
+
         for (i = 0; i < len; i++) 
     {
@@ -1209 +1296 @@
 
 #if DEBUG_EXECUTE
-snprintf( string , 128 , "\n[ksh] in %s : argc = %d / arg0 = %s / arg1 = %s",
-__FUNCTION__ , argc , argv[0], argv[1] );
+printf("\n[ksh] in %s : argc = %d / type = %s", __FUNCTION__ , argc , argv[0] );
 #endif
 
@@ -1245 +1331 @@
         unsigned int   state;                   // escape sequence state
 
-        char           cmd[CMD_MAX_SIZE];               // buffer for one command
 
 /*  direct command to help debug
 
-    int pid = getpid();
-
-    if( pid == 3 )
+    if( getpid() == 2 )
     {
         if( sem_wait( &semaphore ) )
@@ -1260 +1343 @@
         else
         {
-            strcpy( cmd , "load bin/user/tcp_server.elf" );
+            strcpy( cmd , "load bin/user/chat.elf 0" );
             printf("[ksh] %s\n", cmd );
             execute( cmd );
         }
     }
-    else if( getpid() == 4 )
+
+    else if( getpid() == 3 )
     {
         if( sem_wait( &semaphore ) )
@@ -1274 +1358 @@
         else
         {
-            strcpy( cmd , "load bin/user/tcp_client.elf" );
+            strcpy( cmd , "load bin/user/chat.elf 1" );
             printf("[ksh] %s\n", cmd );
             execute( cmd );
@@ -1281 +1365 @@
 
 */
-
 
         enum fsm_states 
@@ -1318 +1401 @@
             state       = NORMAL;
         end_command = 0;
-
-#if DEBUG_INTER 
-snprintf( string , 128 , "[ksh] %s : request a new command", __FUNCTION__ );
-display_string( string );
-#endif
 
         // internal loop on characters in one command
@@ -1349 +1427 @@
                                             cmd[count] = 0;
                         count++;
-#if DEBUG_INTER
-snprintf( string , 128 , "[ksh] %s : get command <%s>", __FUNCTION__, cmd );
-display_string( string );
-#endif
+
                         // register command in log_entries[] array
                                             strncpy( log_entries[ptw].buf , cmd , count );
@@ -1359 +1434 @@
                                             ptr = ptw;
 
-#if DEBUG_INTER
-snprintf( string , 128 , "[ksh] %s : execute <%s>", __FUNCTION__, cmd );
-display_string( string );
-#endif
                         // echo character
                         putchar( c );
@@ -1479 +1550 @@
                 }  // end internal while loop on characters
 
-#if DEBUG_INTER 
-snprintf( string , 128 , "\n[ksh] %s : complete <%s> command", __FUNCTION__, cmd );
-display_string( string );
-#endif
-
         // block interactive thread if KSH loose TXT ownership
         if ( sem_wait( &semaphore ) )
@@ -1518 +1584 @@
 
 #if DEBUG_MAIN
-snprintf( string , 128 , "\n[ksh] main thread started on core[%x,%d]", cxy , lid ); 
-display_string( string );
+printf("\n[ksh] main started on core[%x,%d]", cxy , lid ); 
 #endif
     
@@ -1530 +1595 @@
 
 #if DEBUG_MAIN
-snprintf( string , 128 , "\n[ksh] main initialized semaphore" ); 
-display_string( string );
+printf("\n[ksh] main initialized semaphore" ); 
 #endif
     
@@ -1544 +1608 @@
                     NULL ); 
 #if DEBUG_MAIN
-snprintf( string , 128 , "\n[ksh] main thread launched interactive thread %x", trdid ); 
-display_string( string );
+printf("\n[ksh] main thread launched interactive thread %x", trdid ); 
 #endif
 

trunk/user/sort/sort.c

@@ -54 +54 @@
 #include <hal_macros.h>
 
-#define ARRAY_LENGTH        2048            // number of items
+#define ARRAY_LENGTH        64              // number of items
 #define MAX_THREADS         1024            // 16 * 16 * 4
 

trunk/user/tcp_client/tcp_client.c

@@ -39 +39 @@
         size = get_string( buffer , BUF_SIZE );
 
-/*
-        strcpy( buffer , "blip\n" );
-        printf("%s", buffer ); 
-        size = 5;
-
-        if( send( fdid , buffer , size , 0 ) != size )
-        {
-            printf("\n[server] chat error : cannotl sent message\n");
-            return;
-        }
-*/
-
         // exit chat function when local message is the "exit" string
         if( strncmp( "exit" , buffer , 4 ) == 0 )
         {
+            printf("\n[tcp_client stop] local message is <exit> => return to main\n" );
             return;
         }
@@ -62 +51 @@
         if( nbytes != size )
         {
-            printf("\n[server] send error => chat return to main\n");
+            printf("\n[tcp_client error] cannot send => return to main\n");
             return;
         }
@@ -70 +59 @@
 
         // receive server message
-        nbytes =recv ( fdid, buffer, BUF_SIZE, 0 );
+        nbytes = recv( fdid , buffer , BUF_SIZE , 0 );
 
         if( nbytes < 0 )
         {
-            printf("\n\n[server] receive error => return to main\n" );
+            printf("\n\n[tcp_client error] cannot receive => return to main\n" );
             return;
         }
         else if( nbytes == 0 )
         {
-            printf("\n\n[server] receive EOF => return to main\n" );
+            printf("\n\n[tcp_client stop] receive EOF => return to main\n" );
             return;
         }
@@ -105 +94 @@
     // get  start cycle
     get_cycle( &start_cycle );
-    printf("\n[client] starts at cycle %d\n", (unsigned int)start_cycle );
+    printf("\n[tcp_client] starts at cycle %d\n", (unsigned int)start_cycle );
 
     pid = getpid();
@@ -116 +105 @@
     if( fdid < 0 )
     {
-        printf("\n[client error] cannot create socket\n");
+        printf("\n[tcp_client error] cannot create socket\n");
         exit( 0 );
     }
     else
     {
-        printf("\n[client] created socket[%x,%d]\n", pid, fdid );
+        printf("\n[tcp_client] created socket[%x,%d]\n", pid, fdid );
     }
 
@@ -134 +123 @@
     if( error )
     {
-        printf("\n[client error] bind failure on socketi[%x,%d]\n", pid, fdid );
+        printf("\n[tcp_client error] bind failure on socketi[%x,%d]\n", pid, fdid );
         exit( 0 );
     }
 
-    printf("\n[client] socket[%x,%d] bound : [%x,%x]\n",
+    printf("\n[tcp_client] socket[%x,%d] bound : [%x,%x]\n",
     pid, fdid, client_sin.sin_addr, (unsigned int)client_sin.sin_port );
 
@@ -151 +140 @@
     if( error )
     {
-        printf("\n[client error] connect failure on socket[%x,%d]\n", pid, fdid );
+        printf("\n[tcp_client error] connect failure on socket[%x,%d]\n", pid, fdid );
         exit( 0 );
     }
 
-    printf("\n[client] socket[%x,%d] connected to server [%x,%x]\n",
+    printf("\n[tcp_client] socket[%x,%d] connected to server [%x,%x]\n",
     pid, fdid, server_sin.sin_addr, server_sin.sin_port );
 
@@ -164 +153 @@
     close( fdid );
 
-    printf("\n[client] closed socket[%x,%d]\n", pid, fdid );
+    printf("\n[tcp_client] closed socket[%x,%d]\n", pid, fdid );
 
     exit(0);

trunk/user/tcp_server/tcp_server.c

@@ -40 +40 @@
         if( nbytes < 0 )
         {
-            printf("\n\n[server] receive error => return to main\n" );
+            printf("\n\n[tcp_server error] cannot receive => return to main\n" );
             return;
         }
         else if( nbytes == 0 )
         {
-            printf("\n\n[server] receive EOF => return to main\n" );
+            printf("\n\n[tcp_server stop] received EOF => return to main\n" );
             return;
         }
@@ -61 +61 @@
         if( strncmp( "exit" , buffer , 4 ) == 0 )
         {
+            printf("\n[tcp_server stop] local message is <exit> => return to main\n" );
             return;
         }
@@ -69 +70 @@
         if( nbytes != size )
         {
-            printf("\n[server] send error => chat return to main\n" );
+            printf("\n[tcp_server error] cannot send => return to main\n" );
             return;
         }
@@ -97 +98 @@
     pid = getpid();
 
-    printf("\n[server] starts at cycle %d\n",
+    printf("\n[tcp_server] starts at cycle %d\n",
     (unsigned int)start_cycle );
 
@@ -107 +108 @@
     if( listen_fdid < 0 )
     {
-        printf("\n[server error] cannot create socket\n");
+        printf("\n[tcp_server error] cannot create socket\n");
         exit( 0 );
     }
     else
     {
-        printf("\n[server] created socket[%x,%d]\n", pid, listen_fdid );
+        printf("\n[tcp_server] created socket[%x,%d]\n", pid, listen_fdid );
     }
 
@@ -125 +126 @@
     if( error )
     {
-        printf("\n[server error] bind failure for socket[%x,%d]\n",
+        printf("\n[tcp_server error] bind failure for socket[%x,%d]\n",
         pid, listen_fdid );
         exit( 0 );
     }
 
-    printf("\n[server] listening socket[%x,%d] bound : [%x,%x]\n",
+    printf("\n[tcp_server] listening socket[%x,%d] bound : [%x,%x]\n",
     pid, listen_fdid, server_sin.sin_addr, server_sin.sin_port );
 
@@ -138 +139 @@
     if( error )
     {
-        printf("\n[server error] listen failure for socket[%x,%d]\n",
+        printf("\n[tcp_server error] listen failure for socket[%x,%d]\n",
         pid, listen_fdid );
         exit( 0 );
     }
 
-    printf("\n[server] listening socket[%x,%d] waiting connection request\n",
+    printf("\n[tcp_server] listening socket[%x,%d] waiting connection request\n",
     pid, listen_fdid );
     
@@ -153 +154 @@
     if( chat_fdid < 0 )
     {
-        printf("\n[server error] accept failure on socket[%x,%d]\n",
+        printf("\n[tcp_server error] accept failure on socket[%x,%d]\n",
         pid, listen_fdid );
         exit( 0 );
     }
 
-    printf("\n[server] chat socket[%x,%d] accepted client [%x,%x]\n",
+    printf("\n[tcp_server] chat socket[%x,%d] accepted client [%x,%x]\n",
     pid, chat_fdid , client_sin.sin_addr , client_sin.sin_port );
 
@@ -168 +169 @@
     close( listen_fdid );
 
-    printf("\n[server] closed both <listen> & <chat> sockets\n" );
+    printf("\n[tcp_server] closed both <listen> & <chat> sockets\n" );
 
     exit(0);

trunk/user/transpose/transpose.c

@@ -56 +56 @@
 // local buf_in[cid] buffer, and write pixels to all remote // buf_out[cid] buffers.
 //
-// - The image  must fit the frame buffer size, that must be power of 2.
+// - The image must have [nlines = npixels = IMAGE_SIZE], and cannot exceed the FBF size.
 // - The number of clusters  must be a power of 2 no larger than 256.
 // - The number of cores per cluster must be a power of 2 no larger than 4.
@@ -80 +80 @@
 
 #define IMAGE_TYPE            420                          // pixel encoding type
-
-//#define IMAGE_SIZE            128                          // image size 
-//#define INPUT_FILE_PATH       "/misc/images_128.raw"       // input file pathname 
-//#define OUTPUT_FILE_PATH      "/misc/transposed_128.raw"   // output file pathname 
-
-//#define IMAGE_SIZE            256                          // image size 
-//#define INPUT_FILE_PATH       "/misc/lena_256.raw"         // input file pathname 
-#//define OUTPUT_FILE_PATH      "/misc/transposed_256.raw"   // output file pathname 
-
-//#define IMAGE_SIZE            512                          // image size 
-//#define INPUT_FILE_PATH       "/misc/couple_512.raw"       // input file pathname 
-//#define OUTPUT_FILE_PATH      "/misc/transposed_512.raw"   // output file pathname 
-
-#define IMAGE_SIZE            1024                         // image size 
-#define INPUT_FILE_PATH       "/misc/philips_1024.raw"     // input file pathname 
-#define OUTPUT_FILE_PATH      "/misc/transposed_1024.raw"  // output file pathname 
-
-#define SAVE_RESULT_FILE      0                            // save result image on disk
+#define IMAGE_SIZE            256                          // default image size 
+#define INPUT_IMAGE_PATH      "/misc/lena_256.raw"         // default input image pathname 
+#define OUTPUT_IMAGE_PATH     "/misc/lena_trsp_256.raw"    // default output image pathname 
+
+#define SAVE_RESULT_FILE      1                            // save result image on disk
 #define USE_DQT_BARRIER       0                            // quad-tree barrier if non zero 
 
@@ -108 +95 @@
 #define VERBOSE_EXEC          1                            // exec function print comments
 
+#define INTERACTIVE_MODE      1
 
 ///////////////////////////////////////////////////////
@@ -140 +128 @@
 unsigned char *  buf_out[CLUSTERS_MAX];
 
-// pointer and identifier for dynamically allocated FBF window 
-void   *  win_buf;
-int       wid;
+// pointer and identifier for FBF windows 
+void   *  in_win_buf;
+int       in_wid;
+void   *  out_win_buf;
+int       out_wid;
 
 // synchronisation barrier (all working threads)
@@ -167 +157 @@
 // array of thread attributes / indexed by [tid]
 pthread_attr_t                exec_attr[THREADS_MAX];
+
+// image features
+unsigned int   image_size;
+char           input_image_path[128];
+char           output_image_path[128];
 
 ////////////////////////////////////////////////////////////////
@@ -234 +229 @@
     unsigned int nthreads  = nclusters * ncores;
 
-    if( nthreads > IMAGE_SIZE )
-    {
-        printf("\n[transpose error] number of threads larger than number of lines\n");
-        exit( 0 );
+    // get input and output images path and size
+    if( INTERACTIVE_MODE )
+    {
+        printf("\n - image size : ");
+        get_uint32( &image_size );
+
+        printf("\n - input image path : ");
+        get_string( input_image_path , 128 );
+ 
+        printf(" - output image path : ");
+        get_string( output_image_path , 128 );
+    }
+    else
+    {
+        image_size = IMAGE_SIZE;
+        strcpy( input_image_path , INPUT_IMAGE_PATH );
+        strcpy( input_image_path , OUTPUT_IMAGE_PATH );
     }
 
     // get FBF size and type
-    unsigned int   fbf_width;
-    unsigned int   fbf_height;
-    unsigned int   fbf_type;
+    int   fbf_width;
+    int   fbf_height;
+    int   fbf_type;
     fbf_get_config( &fbf_width , &fbf_height , &fbf_type );
 
-    if( (fbf_width < IMAGE_SIZE) || (fbf_height < IMAGE_SIZE) || (fbf_type != IMAGE_TYPE) )
-    {
-        printf("\n[transpose error] image does not fit FBF size or type\n");
+    // check image 
+    if( nthreads > image_size )
+    {
+        printf("\n[transpose error] nthreads (%d) larger than image size (%d)\n",
+               nthreads , image_size );
+        exit( 0 );
+    }
+
+    if( ((unsigned int)fbf_width  < image_size) ||
+        ((unsigned int)fbf_height < image_size) || 
+        (fbf_type != IMAGE_TYPE) )
+    {
+        printf("\n[transpose error] image not acceptable\n"
+               "FBF width  = %d / npixels  = %d\n"
+               "FBF height = %d / nlines   = %d\n"
+               "FBF type   = %d / expected = %d\n",
+               fbf_width, image_size, fbf_height, image_size, fbf_type, IMAGE_TYPE );
         exit( 0 );
     }
 
     // define total number of pixels
-    int npixels = IMAGE_SIZE * IMAGE_SIZE;
+    int npixels = image_size * image_size;
 
     // define instrumentation file name
@@ -259 +281 @@
     {
         printf("\n[transpose] %d cluster(s) / %d core(s) / <%s> / PID %x / NO_PLACE\n",
-        nclusters, ncores, INPUT_FILE_PATH , getpid() );
+        nclusters, ncores, input_image_path, getpid() );
 
         // build instrumentation file name
         if( USE_DQT_BARRIER )
         snprintf( filename , 32 , "trsp_dqt_no_place_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
+        image_size , x_size * y_size , ncores );
         else
         snprintf( filename , 32 , "trsp_smp_no_place_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
+        image_size , x_size * y_size , ncores );
     }
 
@@ -273 +295 @@
     {
         printf("\n[transpose] %d cluster(s) / %d core(s) / <%s> / PID %x / EXPLICIT\n",
-        nclusters, ncores, INPUT_FILE_PATH , getpid() );
+        nclusters, ncores, input_image_path, getpid() );
 
         // build instrumentation file name
         if( USE_DQT_BARRIER )
         snprintf( filename , 32 , "trsp_dqt_explicit_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
+        image_size , x_size * y_size , ncores );
         else
         snprintf( filename , 32 , "trsp_smp_explicit_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
+        image_size , x_size * y_size , ncores );
     }
 
@@ -287 +309 @@
     {
         printf("\n[transpose] %d cluster(s) / %d core(s) / <%s> / PID %x / PARALLEL\n",
-        nclusters, ncores, INPUT_FILE_PATH , getpid() );
+        nclusters, ncores, input_image_path, getpid() );
 
         // build instrumentation file name
         if( USE_DQT_BARRIER )
         snprintf( filename , 32 , "trsp_dqt_parallel_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
+        image_size , x_size * y_size , ncores );
         else
         snprintf( filename , 32 , "trsp_smp_parallel_%d_%d_%d",
-        IMAGE_SIZE , x_size * y_size , ncores );
-    }
-
-    // open a window in FBF
-    wid = fbf_create_window( 0,             // l_zero
-                             0,             // p_zero
-                             IMAGE_SIZE,    // lines
-                             IMAGE_SIZE,    // pixels
-                             &win_buf );
-    if( wid < 0) 
-    {
-        printf("\n[transpose error] cannot open FBF window\n");
+        image_size , x_size * y_size , ncores );
+    }
+
+    // create an FBF window for input image
+    in_wid = fbf_create_window( 0,                // l_zero
+                                0,                // p_zero
+                                image_size,       // lines
+                                image_size,       // pixels
+                                &in_win_buf );    // pointer on buffer in user space
+    if( in_wid < 0) 
+    {
+        printf("\n[transpose error] cannot create window for %s\n", input_image_path );
+        exit( 0 );
+    }
+
+    // activate window
+    error = fbf_active_window( in_wid , 1 );
+
+    if( error )
+    {
+        printf("\n[transpose error] cannot activate window for %s\n", input_image_path );
         exit( 0 );
     }
 
 #if  VERBOSE_MAIN
-printf("\n[transpose] main on core[%x,%d] created FBF window %d / buffer %x\n",
-cxy_main, lid_main, wid , win_buf );
+printf("\n[transpose] main on core[%x,%d] created window for %s / wid %d / buf %x\n",
+cxy_main, lid_main, input_image_path, in_wid , in_win_buf );
+#endif
+
+    // create an FBF window for output image
+    out_wid = fbf_create_window( image_size,       // l_zero
+                                 image_size,       // p_zero
+                                 image_size,       // lines
+                                 image_size,       // pixels
+                                 &out_win_buf );   // pointer on buffer in user space
+    if( out_wid < 0) 
+    {
+        printf("\n[transpose error] cannot create window for %s\n", output_image_path );
+        exit( 0 );
+    }
+
+    // activate window
+    error = fbf_active_window( out_wid , 1 );
+
+    if( error )
+    {
+        printf("\n[transpose error] cannot activate window for %s\n", output_image_path );
+        exit( 0 );
+    }
+
+#if  VERBOSE_MAIN
+printf("\n[transpose] main on core[%x,%d] created window for %s / wid %d / buf %x\n",
+cxy_main, lid_main, output_image_path, out_wid , out_win_buf );
 #endif
 
@@ -356 +413 @@
 
     // open input file
-    int fd_in = open( INPUT_FILE_PATH , O_RDONLY , 0 ); 
+    int fd_in = open( input_image_path , O_RDONLY , 0 ); 
 
     if ( fd_in < 0 ) 
     { 
-        printf("\n[transpose error] main cannot open file %s\n", INPUT_FILE_PATH );
+        printf("\n[transpose error] main cannot open file %s\n", input_image_path );
         exit( 0 );
     }
 
 #if  VERBOSE_MAIN
-printf("\n[transpose] main open file <%s> / fd = %d\n", INPUT_FILE_PATH , fd_in );
+printf("\n[transpose] main open file <%s> / fd = %d\n", input_image_path , fd_in );
 #endif
 
     // open output file
-    int fd_out = open( OUTPUT_FILE_PATH , O_CREAT , 0 ); 
+    int fd_out = open( output_image_path , O_CREAT , 0 ); 
 
     if ( fd_out < 0 ) 
     { 
-        printf("\n[transpose error] main cannot open file %s\n", OUTPUT_FILE_PATH );
+        printf("\n[transpose error] main cannot open file %s\n", output_image_path );
         exit( 0 );
     }
@@ -385 +442 @@
 
 #if  VERBOSE_MAIN
-printf("\n[transpose] main moved file <%s> to buf_in\n", INPUT_FILE_PATH );
+printf("\n[transpose] main moved file <%s> to buf_in\n", input_image_path );
 #endif
 
@@ -621 +678 @@
 #endif
 
-    // delete FBF window 
-    if( fbf_delete_window( wid ) )
+    // delete FBF windows
+    if( fbf_delete_window( in_wid ) )
+    if( fbf_delete_window( out_wid ) )
     {
         printf("\n[transpose error] main cannot delete FBF window\n");
         exit( 0 );
     }
+
+#if VERBOSE_MAIN
+printf("\n[transpose] main deleted FBF windows\n");
+#endif
 
     // main thread suicide
@@ -634 +696 @@
 
 } // end main()
+
+
+
+
 
 
@@ -646 +712 @@
     int                  error;
 
-    unsigned char      * wbuf = win_buf;
- 
     pthread_parallel_work_args_t * args = (pthread_parallel_work_args_t *)arguments;
 
@@ -678 +742 @@
 
     // compute total number of pixels per image
-    unsigned int npixels = IMAGE_SIZE * IMAGE_SIZE;      
+    unsigned int npixels = image_size * image_size;      
 
     // compute total number of threads and clusters
@@ -689 +753 @@
 
     // compute first and last line per thread
-    unsigned int lines_per_cid = pixels_per_cid / IMAGE_SIZE;
-    unsigned int lines_per_lid = pixels_per_lid / IMAGE_SIZE;
+    unsigned int lines_per_cid = pixels_per_cid / image_size;
+    unsigned int lines_per_lid = pixels_per_lid / image_size;
 
     unsigned int line_first = (cid * lines_per_cid) + (lid * lines_per_lid);
@@ -751 +815 @@
 
     // all local threads copy part of buf_in[cid] to FBF window for display
-    memcpy( wbuf + (cid * pixels_per_cid) + (lid * pixels_per_lid),
+    memcpy( in_win_buf + (cid * pixels_per_cid) + (lid * pixels_per_lid),
             buf_in[cid] + (lid * pixels_per_lid),
             pixels_per_lid );
@@ -760 +824 @@
 #endif
 
-    // retresh window
-    error = fbf_refresh_window( wid , line_first , line_last );
+    // all threads contribute to input window refresh
+    error = fbf_refresh_window( in_wid , line_first , line_last );
 
     if( error )
@@ -785 +849 @@
     // (l,p) are the absolute pixel coordinates in the dest image
 
-    unsigned int nlt   = IMAGE_SIZE / nthreads;    // number of lines per thread
-    unsigned int nlc   = IMAGE_SIZE / nclusters;   // number of lines per cluster
+    unsigned int nlt   = image_size / nthreads;    // number of lines per thread
+    unsigned int nlc   = image_size / nclusters;   // number of lines per cluster
 
     unsigned int src_cid;
@@ -802 +866 @@
     {
         // loop on pixels in one line (one pixel per iteration)
-        for ( p = 0 ; p < IMAGE_SIZE ; p++ )
+        for ( p = 0 ; p < image_size ; p++ )
         {
             // read one byte from local buf_in
             src_cid   = l / nlc;
-            src_index = (l % nlc) * IMAGE_SIZE + p;
+            src_index = (l % nlc) * image_size + p;
 
             byte = buf_in[src_cid][src_index];
@@ -812 +876 @@
             // write one byte to remote buf_out
             dst_cid   = p / nlc; 
-            dst_index = (p % nlc) * IMAGE_SIZE + l;
+            dst_index = (p % nlc) * image_size + l;
 
             buf_out[dst_cid][dst_index] = byte;
@@ -834 +898 @@
 
     // each local threads copy part of buf_out[cid] to FBF window for display
-    memcpy( wbuf + (cid * pixels_per_cid) + (lid * pixels_per_lid),
+    memcpy( out_win_buf + (cid * pixels_per_cid) + (lid * pixels_per_lid),
             buf_out[cid] + (lid * pixels_per_lid),
             pixels_per_lid );
@@ -843 +907 @@
 #endif
 
-    // refresh window
-    error = fbf_refresh_window( wid , line_first , line_last );
+    // each thread contributes to output window refresh
+    error = fbf_refresh_window( out_wid , line_first , line_last );
 
     if( error )