Changeset 656 for trunk/user

Timestamp:

Dec 6, 2019, 12:07:51 PM (5 years ago)

Author:

alain

Message:

Fix several bugs in the FATFS and in the VFS,
related to the creation of big files requiring
more than 4 Kbytes (one cluster) on device.

Location:

trunk/user

Files:

• convol/convol.c (modified) (24 diffs)
• convol/convol.ld (modified) (1 diff)
• display/Makefile (modified) (2 diffs)
• display/display.c (modified) (2 diffs)
• fft/fft.c (modified) (7 diffs)
• ksh/ksh.c (modified) (1 diff)
• sort/sort.c (modified) (4 diffs)
• transpose/transpose.c (modified) (6 diffs)

trunk/user/convol/convol.c

@@ -65 +65 @@
 
 #define VERBOSE_MAIN               1
-#define VERBOSE_EXEC               1
+#define VERBOSE_EXEC               0
+#define SUPER_VERBOSE              0
 
 #define X_MAX                      16
@@ -159 +160 @@
 /////////////////////////////////////////////////////////////////////////////////////
 
-void execute( pthread_parallel_work_args_t * args );
+void * execute( void * args );
 
 void instrument( FILE * f , char * filename );
@@ -173 +174 @@
 
     char         instru_name[32];               // instrumentation file name
-    char         instru_path[64];              // instrumentation path name
+    char         instru_path[64];               // instrumentation path name
 
     /////////////////////////////////////////////////////////////////////////////////
@@ -255 +256 @@
         // build instrumentation file name
         if( USE_DQT_BARRIER )
-        snprintf( instru_name , 32 , "conv_dqt_explicit_%d_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "conv_dqt_explicit_%d_%d", x_size * y_size , ncores );
         else
-        snprintf( instru_name , 32 , "conv_smp_explicit_%d_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "conv_smp_explicit_%d_%d", x_size * y_size , ncores );
     }
 
@@ -267 +268 @@
         // build instrumentation file name
         if( USE_DQT_BARRIER )
-        snprintf( instru_name , 32 , "conv_dqt_parallel_%d_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "conv_dqt_parallel_%d_%d", x_size * y_size , ncores );
         else
-        snprintf( instru_name , 32 , "conv_smp_parallel_%d_%d_%d", x_size * y_size , ncores );
+        snprintf( instru_name , 32 , "conv_smp_parallel_%d_%d", x_size * y_size , ncores );
     }
 
@@ -380 +381 @@
     /////////////////////////////////////////////////////////////////////////////////////
 
-    //////////////////
-    if( NO_PLACEMENT )
-    {
-        // the tid value for the main thread is always 0
-        // main thread creates new threads with tid in [1,nthreads-1]  
-        unsigned int tid;
-        for ( tid = 0 ; tid < nthreads ; tid++ )
-        {
-            // register tid value in exec_args[tid] array
-            exec_args[tid].tid = tid;
-            
-            // create other threads
-            if( tid > 0 )
+//////////////////
+#if NO_PLACEMENT
+{
+    // the tid value for the main thread is always 0
+    // main thread creates new threads with tid in [1,nthreads-1]  
+    unsigned int tid;
+    for ( tid = 0 ; tid < nthreads ; tid++ )
+    {
+        // register tid value in exec_args[tid] array
+        exec_args[tid].tid = tid;
+          
+        // create other threads
+        if( tid > 0 )
+        {
+            if ( pthread_create( &exec_trdid[tid], 
+                                 NULL,                  // no attribute
+                                 &execute,
+                                 &exec_args[tid] ) ) 
             {
-                if ( pthread_create( &exec_trdid[tid], 
-                                     NULL,                  // no attribute
-                                     &execute,
-                                     &exec_args[tid] ) ) 
-                {
-                    printf("\n[convol error] cannot create thread %d\n", tid );
-                    exit( 0 );
-                }
+                printf("\n[convol error] cannot create thread %d\n", tid );
+                exit( 0 );
+            }
 
 #if VERBOSE_MAIN
@@ -407 +408 @@
 #endif
 
+        }
+        else
+        {
+            tid_main = 0;
+        }
+    }  // end for tid
+
+    // main thread calls itself the execute() function
+    execute( &exec_args[0] );
+
+    // main thread wait other threads completion
+    for ( tid = 1 ; tid < nthreads ; tid++ )
+    {
+        unsigned int * status;
+
+        // main wait thread[tid] status
+        if ( pthread_join( exec_trdid[tid], (void*)(&status)) )
+        {
+            printf("\n[convol error] main cannot join thread %d\n", tid );
+            exit( 0 );
+        }
+       
+        // check status
+        if( *status != THREAD_EXIT_SUCCESS )
+        {
+            printf("\n[convol error] thread %x returned failure\n", tid );
+            exit( 0 );
+        }
+
+#if VERBOSE_MAIN 
+printf("\n[convol] main successfully joined thread %x\n", tid );
+#endif
+        
+    }  // end for tid
+}  
+#endif // end no_placement
+
+//////////////////////
+#if EXPLICIT_PLACEMENT
+{
+    // main thread places each other threads on a specific core[cxy][lid]
+    // but the actual thread creation is sequencial
+    unsigned int x;
+    unsigned int y;
+    unsigned int l;
+    unsigned int cxy;                   // cluster identifier
+    unsigned int tid;                   // thread continuous index
+
+    for( x = 0 ; x < x_size ; x++ )
+    {
+        for( y = 0 ; y < y_size ; y++ )
+        {
+            cxy = HAL_CXY_FROM_XY( x , y );
+            for( l = 0 ; l < ncores ; l++ )
+            {
+                // compute thread continuous index
+                tid = (((x  * y_size) + y) * ncores) + l;
+
+                // register tid value in exec_args[tid] array
+                exec_args[tid].tid = tid;
+
+                // no thread created on the core running the main
+                if( (cxy != cxy_main) || (l != lid_main) )
+                {
+                    // define thread attributes
+                    exec_attr[tid].attributes = PT_ATTR_CLUSTER_DEFINED |
+                                                PT_ATTR_CORE_DEFINED;
+                    exec_attr[tid].cxy        = cxy;
+                    exec_attr[tid].lid        = l;
+ 
+                    // create thread[tid] on core[cxy][l]
+                    if ( pthread_create( &exec_trdid[tid],    
+                                         &exec_attr[tid],    
+                                         &execute,
+                                         &exec_args[tid] ) )       
+                    {
+                        printf("\n[convol error] cannot create thread %d\n", tid );
+                        exit( 0 );
+                    }
+#if VERBOSE_MAIN 
+printf("\n[convol] main created thread[%d] on core[%x,%d]\n", tid, cxy, l );
+#endif
+                }
+                else
+                {
+                    tid_main = tid;
+                }
             }
-            else
-            {
-                tid_main = 0;
-            }
-        }  // end for tid
-
-        // main thread calls itself the execute() function
-        execute( &exec_args[0] );
-
-        // main thread wait other threads completion
-        for ( tid = 1 ; tid < nthreads ; tid++ )
+        }
+    }
+
+    // main thread calls itself the execute() function
+    execute( &exec_args[tid_main] );
+
+    // main thread wait other threads completion
+    for( tid = 0 ; tid < nthreads ; tid++ )
+    {
+        // no other thread on the core running the main
+        if( tid != tid_main )
         {
             unsigned int * status;
 
-            // main wait thread[tid] status
-            if ( pthread_join( exec_trdid[tid], (void*)(&status)) )
+            // wait thread[tid]
+            if( pthread_join( exec_trdid[tid] , (void*)(&status) ) )
             {
                 printf("\n[convol error] main cannot join thread %d\n", tid );
                 exit( 0 );
             }
-       
+     
             // check status
             if( *status != THREAD_EXIT_SUCCESS )
             {
-                printf("\n[convol error] thread %x returned failure\n", tid );
+                printf("\n[convol error] thread %d returned failure\n", tid );
                 exit( 0 );
             }
-
-#if VERBOSE_MAIN 
-printf("\n[convol] main successfully joined thread %x\n", tid );
-#endif
-        
-        }  // end for tid
-
-    }  // end if no_placement
-
-    ////////////////////////
-    if( EXPLICIT_PLACEMENT )
-    {
-        // main thread places each other threads on a specific core[cxy][lid]
-        // but the actual thread creation is sequencial
-        unsigned int x;
-        unsigned int y;
-        unsigned int l;
-        unsigned int cxy;                   // cluster identifier
-        unsigned int tid;                   // thread continuous index
-
-        for( x = 0 ; x < x_size ; x++ )
-        {
-            for( y = 0 ; y < y_size ; y++ )
-            {
-                cxy = HAL_CXY_FROM_XY( x , y );
-                for( l = 0 ; l < ncores ; l++ )
-                {
-                    // compute thread continuous index
-                    tid = (((x  * y_size) + y) * ncores) + l;
-
-                    // register tid value in exec_args[tid] array
-                    exec_args[tid].tid = tid;
-
-                    // no thread created on the core running the main
-                    if( (cxy != cxy_main) || (l != lid_main) )
-                    {
-                        // define thread attributes
-                        exec_attr[tid].attributes = PT_ATTR_CLUSTER_DEFINED |
-                                                    PT_ATTR_CORE_DEFINED;
-                        exec_attr[tid].cxy        = cxy;
-                        exec_attr[tid].lid        = l;
-  
-                        // create thread[tid] on core[cxy][l]
-                        if ( pthread_create( &exec_trdid[tid],    
-                                             &exec_attr[tid],    
-                                             &execute,
-                                             &exec_args[tid] ) )       
-                        {
-                            printf("\n[convol error] cannot create thread %d\n", tid );
-                            exit( 0 );
-                        }
-#if VERBOSE_MAIN 
-printf("\n[convol] main created thread[%d] on core[%x,%d]\n", tid, cxy, l );
-#endif
-                    }
-                    else
-                    {
-                        tid_main = tid;
-                    }
-                }
-            }
-        }
-
-        // main thread calls itself the execute() function
-        execute( &exec_args[tid_main] );
-
-        // main thread wait other threads completion
-        for( tid = 0 ; tid < nthreads ; tid++ )
-        {
-            // no other thread on the core running the main
-            if( tid != tid_main )
-            {
-                unsigned int * status;
-
-                // wait thread[tid]
-                if( pthread_join( exec_trdid[tid] , (void*)(&status) ) )
-                {
-                    printf("\n[convol error] main cannot join thread %d\n", tid );
-                    exit( 0 );
-                }
-       
-                // check status
-                if( *status != THREAD_EXIT_SUCCESS )
-                {
-                    printf("\n[convol error] thread %d returned failure\n", tid );
-                    exit( 0 );
-                }
 #if VERBOSE_MAIN 
 printf("\n[convol] main joined thread %d on core[%x,%d]\n", tid , cxy , l );
 #endif
-            }
-        }
-    }  // end if explicit_placement
-
-    ////////////////////////
-    if( PARALLEL_PLACEMENT )
-    {
-        // compute covering DQT size an level
-        unsigned int z          = (x_size > y_size) ? x_size : y_size;
-        unsigned int root_level = ((z == 1) ? 0 : 
-                                  ((z == 2) ? 1 : 
-                                  ((z == 4) ? 2 : 
-                                  ((z == 8) ? 3 : 4))));
-
-        // create & execute the working threads
-        if( pthread_parallel_create( root_level , &execute ) )
-        {
-            printf("\n[convol error] in %s\n", __FUNCTION__ );
-            exit( 0 );
-        }
-    }  // end if parallel_placement
+        }
+    }
+} 
+#endif   // end explicit_placement
+
+//////////////////////
+#if PARALLEL_PLACEMENT
+{
+    // compute covering DQT size an level
+    unsigned int z          = (x_size > y_size) ? x_size : y_size;
+    unsigned int root_level = ((z == 1) ? 0 : 
+                              ((z == 2) ? 1 : 
+                              ((z == 4) ? 2 : 
+                              ((z == 8) ? 3 : 4))));
+
+    // create & execute the working threads
+    if( pthread_parallel_create( root_level , &execute ) )
+    {
+        printf("\n[convol error] in %s\n", __FUNCTION__ );
+        exit( 0 );
+    }
+}
+#endif  // end parallel_placement
 
     /////////////////////////////////////////////////////////////////////////////
@@ -555 +558 @@
     instrument( f_instru , instru_name );
 
+#if VERBOSE_MAIN 
+printf("\n[convol] main registered instrumentation info\n" );
+#endif
+
     // main thread close input file
     close( fd_in );
 
+#if VERBOSE_MAIN 
+printf("\n[convol] main closed input file\n" );
+#endif
+
     // main thread close output file
     close( fd_out );
 
+#if VERBOSE_MAIN 
+printf("\n[convol] main closed output file\n" );
+#endif
+
     // main thread close instrumentation file
     fclose( f_instru );
+
+#if VERBOSE_MAIN 
+printf("\n[convol] main closed instrumentation file\n" );
+#endif
 
     // main thread suicide 
@@ -574 +593 @@
 
 
-///////////////////////////////////////////////////
-void execute( pthread_parallel_work_args_t * args )
+//////////////////////////////////
+void * execute( void * arguments )
+
 {
     unsigned long long date;
+
+    pthread_parallel_work_args_t * args = (pthread_parallel_work_args_t *)arguments;
 
     // Each thread initialises the convolution kernel parameters in local stack.
@@ -610 +632 @@
 unsigned int cxy;              // core cluster identifier
 unsigned int lpid;             // core local identifier
+get_cycle( &date );
 get_core_id( &cxy , &lpid );
-printf("\n[convol] exec[%d] on core[%x,%d] enters parallel exec\n",
-tid , cxy , lpid );
+printf("\n[convol] exec[%d] on core[%x,%d] enters parallel exec / cycle %d\n",
+tid , cxy , lpid , (unsigned int)date );
 #endif
 
@@ -639 +662 @@
 
     // Each thread[cid][0] allocates 5 local buffers, 
-    // shared by all threads that have the same cid 
+    // and registers these 5 pointers in the global arrays
     if ( lid == 0 )
     {
@@ -656 +679 @@
 
 #if VERBOSE_EXEC
-printf( "\n[convol] exec[%d] on core[%x,%d] allocated shared buffers\n"
-"### GA = %x\n"
-"### GB = %x\n"               
-"### GC = %x\n"               
-"### GD = %x\n"               
-"### GZ = %x\n",
-tid, cxy , lpid, GA[cid], GB[cid], GC[cid], GD[cid], GZ[cid] );
+get_cycle( &date );
+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] );
 #endif
     
@@ -700 +720 @@
 #if VERBOSE_EXEC
 get_cycle( &date );
-printf( "\n[convol] thread %d on core[%x,%d] load input file in A[%d]\n", 
-tid , cxy , lpid , cid );
+printf( "\n[convol] exec[%d] on core[%x,%d] loaded input file in A[%d] / cycle %d\n", 
+tid , cxy , lpid , cid , (unsigned int)date);
 #endif
 
@@ -729 +749 @@
                            NP*(l + (tid * lines_per_thread))))    // offset in FBF
             {
-                printf("\n[convol error] in %s : thread[%x,%d] cannot access FBF\n",
-                __FUNCTION__ , cxy , lid );
+                printf("\n[convol error] in %s : thread[%d] cannot access FBF\n",
+                __FUNCTION__ , tid );
                 pthread_exit( &THREAD_EXIT_FAILURE );
             }
@@ -737 +757 @@
 #if VERBOSE_EXEC 
 get_cycle( &date );
-printf( "\n[convol] thread[%d] on core[%x,%d] completes initial display\n",
-tid , cxy , lpid );
+printf( "\n[convol] exec[%d] on core[%x,%d] completed initial display / cycle %d\n",
+tid , cxy , lpid , (unsigned int)date );
 #endif
 
@@ -758 +778 @@
     H_BEG[cid][lid] = (unsigned int)date;
 
-#if VERBOSE_EXEC 
-printf( "\n[convol] thread[%d] on core[%x,%d] starts horizontal filter\n",
-tid , cxy , lpid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] starts horizontal filter\n",
-tid , cxy , lpid );
-#endif
-
     // l = absolute line index / p = absolute pixel index  
     // first & last define which lines are handled by a given thread
@@ -833 +844 @@
 
 #if VERBOSE_EXEC 
-printf( "\n[convol] thread[%d] on core[%x,%d] completes horizontal filter\n",
-tid , cxy , lpid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] completes horizontal filter\n",
-tid , cxy , lpid );
+get_cycle( &date );
+printf( "\n[convol] exec[%d] on core[%x,%d] completed horizontal filter / cycle %d\n",
+tid , cxy , lpid , (unsigned int)date );
 #endif
 
@@ -855 +863 @@
     get_cycle( &date );
     V_BEG[cid][lid] = (unsigned int)date;
-
-#if VERBOSE_EXEC 
-printf( "\n[convol] thread[%d] on core[%x,%d] starts vertical filter\n",
-tid , cxy , lpid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] starts vertical filter\n",
-tid , cxy , lpid );
-#endif
 
     // l = absolute line index / p = absolute pixel index
@@ -947 +946 @@
 
 #if VERBOSE_EXEC 
-printf( "\n[convol] thread[%d] on core[%x,%d] completes vertical filter\n",
-tid , cxy , lid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] completes vertical filter\n",
-tid , cxy , lid );
+get_cycle( &date );
+printf( "\n[convol] exec[%d] on core[%x,%d] completed vertical filter / cycle %d\n",
+tid , cxy , lid , (unsigned int)date );
 #endif
 
@@ -965 +961 @@
         get_cycle( &date );
         D_BEG[cid][lid] = (unsigned int)date;
-
-#if VERBOSE_EXEC
-printf( "\n[convol] thread[%d] on core[%x,%d] starts final display\n",
-tid , cxy , lid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] starts final display\n",
-tid , cxy , lid );
-#endif
 
         unsigned int line;
@@ -1002 +989 @@
 
 #if VERBOSE_EXEC
-printf( "\n[convol] thread[%d] on core[%x,%d] completes final display\n",
-tid , cxy , lid );
-#else
-if ( tid == tid_main ) 
-printf( "\n[convol] thread[%d] on core[%x,%d] completes final display\n",
-tid , cxy , lid );
-#endif
-
-    }
-
-    // all threads (but the one executing main) exit
-    if ( tid != tid_main )
-    {
+get_cycle( &date );
+printf( "\n[convol] exec[%d] on core[%x,%d] completed final display / cycle %d\n",
+tid , cxy , lid , (unsigned int)date );
+#endif
+
+    }
+
+    // Each thread[cid,0] releases the 5 local buffers
+    if( lid == 0 )
+    {
+        free( A[cid] );
+        free( B[cid] );
+        free( C[cid] );
+        free( D[cid] );
+        free( Z[cid] );
+    }
+
+    // thread termination depends on the placement policy
+    if( PARALLEL_PLACEMENT )   
+    {
+        // <exec> threads are runing in detached mode, and
+        // each thread must signal completion by calling barrier
+        // passed in arguments before exit
+
+        pthread_barrier_wait( args->barrier );
+
         pthread_exit( &THREAD_EXIT_SUCCESS );
     }
+    else
+    {
+        // <exec> threads are running in attached mode
+        // all threads (but the one executing main) exit
+        if ( tid != tid_main ) pthread_exit( &THREAD_EXIT_SUCCESS );
+    }
+
+    return NULL;
 
 } // end execute()
@@ -1102 +1110 @@
            min_d_end, max_d_end, (min_d_end+max_d_end)/2, max_d_end-min_d_end);
 
-    printf( "\n General Scenario (Kcycles for each step)\n" );
+    printf( "\n General Scenario   (Kcycles)\n" );
     printf( " - LOAD IMAGE        = %d\n", (min_h_beg - min_start)/1000 );
     printf( " - H_FILTER          = %d\n", (max_h_end - min_h_beg)/1000 );
@@ -1109 +1117 @@
     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( " \nSEQUENCIAL = %d / PARALLEL = %d\n", SEQUENCIAL_TIME, PARALLEL_TIME );
+    printf( " \nSEQUENCIAL = %d / PARALLEL = %d\n",
+            SEQUENCIAL_TIME/1000, PARALLEL_TIME/1000 );
 
     // save on disk
@@ -1142 +1151 @@
     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 ,  " \nSEQUENCIAL = %d / PARALLEL = %d\n", SEQUENCIAL_TIME, PARALLEL_TIME );
+    fprintf( f ,  " \nSEQUENCIAL = %d / PARALLEL = %d\n",
+    SEQUENCIAL_TIME/1000, PARALLEL_TIME/1000 );
 
 } // end instrument()

trunk/user/convol/convol.ld

@@ -4 +4 @@
 
 seg_code_base      = 0x400000;
+
+/***************************************************************************
+* Define code entry point (e_entry field in .elf file)
+***************************************************************************/
+
+ENTRY( main )
 
 /***************************************************************************

trunk/user/display/Makefile

@@ -22 +22 @@
 build/display.elf : $(OBJS) display.ld
         $(LD) -o $@ -T display.ld $(OBJS) -L$(LIBC) -L$(LIBPTHREAD) -L$(LIBALMOSMKH) \
-         -lc -lpthread -lalmosmkh -lpthread -lc 
+          -lc -lpthread -lalmosmkh -lpthread -lc 
         $(DU) -D $@ > $@.txt
 
@@ -35 +35 @@
 
 .PHONY: dirs clean
-
+ 

trunk/user/display/display.c

@@ -56 +56 @@
     }
 }        
-////////////
-void main()
+////////////////
+int main( void )
 {
 
@@ -141 +141 @@
    
     exit(0);
+
+    return 0;
 }

trunk/user/fft/fft.c

@@ -177 +177 @@
 
 // array of kernel thread identifiers / indexed by [tid]
-pthread_t      work_trdid[CLUSTERS_MAX * CORES_MAX];   
+pthread_t                     work_trdid[CLUSTERS_MAX * CORES_MAX];   
 
 // array of thread attributes / indexed by [tid]
-pthread_attr_t work_attr[CLUSTERS_MAX * CORES_MAX];
+pthread_attr_t                work_attr[CLUSTERS_MAX * CORES_MAX];
 
 // array of work function arguments / indexed by [tid]
-pthread_parallel_work_args_t work_args[CLUSTERS_MAX * CORES_MAX];
+pthread_parallel_work_args_t  work_args[CLUSTERS_MAX * CORES_MAX];
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -189 +189 @@
 /////////////////////////////////////////////////////////////////////////////////////
 
-void work( pthread_parallel_work_args_t * args );
+void * work( void * args );
 
 double CheckSum( void );
@@ -254 +254 @@
 // launch the parallel execution, and makes the instrumentation.
 ///////////////////////////////////////////////////////////////////
-void main ( void )
+int main ( void )
 {
     int                 error;
@@ -699 +699 @@
     exit( 0 );
 
+    return 0;
+
 } // end main()
 
@@ -704 +706 @@
 // This function is executed in parallel by all <work> threads.
 /////////////////////////////////////////////////////////////////
-void work( pthread_parallel_work_args_t * args ) 
+void * work( void * arguments )
 {
     unsigned int        tid;              // this thread continuous index
     unsigned int        lid;              // core local index 
     unsigned int        cid;              // cluster continuous index
-    pthread_barrier_t * parent_barrier;   // pointer on parent barrier
 
     unsigned int        MyFirst;          // index first row allocated to thread
@@ -723 +724 @@
 
     // get thread arguments
-    tid            = args->tid; 
-    parent_barrier = args->barrier;
+    pthread_parallel_work_args_t * args = (pthread_parallel_work_args_t *)arguments;
+    
+    tid                                = args->tid; 
+    pthread_barrier_t * parent_barrier = args->barrier;
 
     // compute lid and cid from tid
@@ -861 +864 @@
     //  work thread exit 
     pthread_exit( NULL );
+
+    return NULL;
 
 }  // end work()

trunk/user/ksh/ksh.c

@@ -1234 +1234 @@
 else
 {
-    strcpy( cmd , "load bin/user/transpose.elf" );
+    strcpy( cmd , "load bin/user/kleenex.elf" );
     printf("[ksh] %s\n", cmd );
     execute( cmd );

trunk/user/sort/sort.c

@@ -153 +153 @@
 }  // end merge()
 
-///////////////////////////////////////////////
-void sort( pthread_parallel_work_args_t * ptr )
+///////////////////////////////
+void * sort( void * arguments )
 {
     unsigned int        i;
@@ -161 +161 @@
 
     // get arguments
+    pthread_parallel_work_args_t * ptr = (pthread_parallel_work_args_t *)arguments;
+
     unsigned int        tid            = ptr->tid;
     pthread_barrier_t * parent_barrier = ptr->barrier;
@@ -237 +239 @@
     pthread_exit( NULL );
 
+    return NULL;
+
 } // end sort()
 
 
-/////////////////
-void main( void )
+////////////////
+int main( void )
 {
     int                    error;
@@ -452 +456 @@
     exit( 0 );
 
+    return 0;
+
 }  // end main()
 

trunk/user/transpose/transpose.c

@@ -154 +154 @@
 ////////////////////////////////////////////////////////////////
 
-void execute( pthread_parallel_work_args_t * args );
+void * execute( void * arguments );
 
 void instrument( FILE * f , char * filename );
 
-/////////////////
-void main( void )
+////////////////
+int main( void )
 {
     unsigned long long start_cycle;
@@ -586 +586 @@
     exit( 0 );
     
+    return 0;
+
 } // end main()
 
@@ -591 +593 @@
 
 
-///////////////////////////////////////////////////
-void execute( pthread_parallel_work_args_t * args )
+//////////////////////////////////
+void * execute( void * arguments ) 
 {
     unsigned long long   date;
@@ -598 +600 @@
     unsigned int l;                         // line index for loop
     unsigned int p;                         // pixel index for loop
+
+    pthread_parallel_work_args_t * args = (pthread_parallel_work_args_t *)arguments;
 
     // WARNING 
@@ -813 +817 @@
     if( PARALLEL_PLACEMENT )   
     {
-        // <work> threads are runing in detached mode
+        // <work> threads are runing in detached mode, and
         // each thread must signal completion by calling barrier
         // passed in arguments before exit
@@ -827 +831 @@
         if ( tid != tid_main )  pthread_exit( &THREAD_EXIT_SUCCESS );
     }
+
+    return NULL;
 
 } // end execute()