Changeset 635 for trunk/user/sort

Timestamp:

Jun 26, 2019, 11:42:37 AM (5 years ago)

Author:

alain

Message:

This version is a major evolution: The physical memory allocators,
defined in the kmem.c, ppm.c, and kcm.c files have been modified
to support remote accesses. The RPCs that were previously user
to allocate physical memory in a remote cluster have been removed.
This has been done to cure a dead-lock in case of concurrent page-faults.

This version 2.2 has been tested on a (4 clusters / 2 cores per cluster)
TSAR architecture, for both the "sort" and the "fft" applications.

File:

• trunk/user/sort/sort.c (modified) (11 diffs)

trunk/user/sort/sort.c

@@ +1 @@
+/*
+ * sort.c - Parallel sort
+ * 
+ * Author     Cesar Fuguet Tortolero (2013)
+ *            Alain Greiner (2019)
+ *
+ * Copyright (c) UPMC Sorbonne Universites
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2.0 of the License.
+ *
+ * It is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
 ///////////////////////////////////////////////////////////////////////////////
-// File   :  sort.c
-// Date   :  November 2013
-// Author :  Cesar Fuguet Tortolero <cesar.fuguet-tortolero@lip6.fr>
-///////////////////////////////////////////////////////////////////////////////
-// This multi-threaded application implement a multi-stage sort application.
-// The various stages are separated by synchronisation barriers.
+// This multi-threaded application implement a multi-stage sort.
+// It has been writen by Cesar Fuget Tortolero in 2013.
+// It has been ported on ALMOS-MKH by Alain Greiner in 2019.
+//
 // There is one thread per physical cores. 
 // Computation is organised as a binary tree: 
@@ -15 +35 @@
 //       Number_of_stages = number of barriers = log2(Number_of_threads)
 //
+// The various stages are separated by synchronisation barriers, and the
+// main thread uses the join syscall to check that all threads completed
+// before printing the computation time (sequencial & parallel). 
+// These results can be - optionnaly - registered in an instrumentation file.
+//
 // Constraints :
 // - It supports up to 1024 cores: x_size, y_size, and ncores must be
@@ -29 +54 @@
 #include <hal_macros.h>
 
-#define ARRAY_LENGTH        4096       // number of items
+#define ARRAY_LENGTH        128        // number of items
 #define MAX_THREADS         1024       // 16 * 16 * 4
 
 #define USE_DQT_BARRIER     1          // use DQT barrier if non zero
 #define DISPLAY_ARRAY       0          // display items values before and after
-#define DEBUG_MAIN          1          // trace main function
-#define DEBUG_SORT          1          // trace sort function
-#define INTERACTIVE_MODE    0          // activate idbg() during instrumentation
+#define DEBUG_MAIN          0          // trace main function
+#define DEBUG_SORT          0          // trace sort function
 #define CHECK_RESULT        0          // for debug
 #define INSTRUMENTATION     1          // register computation times on file
-#define IDBG                0          // activate interactive debug in main
 
 /////////////////////////////////////////////////////////////
@@ -62 +85 @@
 pthread_barrier_t   barrier;                 // synchronisation variables
 
-pthread_attr_t      attr[MAX_THREADS];       // thread attributes (one per thread)
-args_t              arg[MAX_THREADS];        // sort function arguments (one per thread)
+pthread_t           trdid[MAX_THREADS];      // kernel identifiers
+pthread_attr_t      attr[MAX_THREADS];       // thread attributes
+args_t              arg[MAX_THREADS];        // sort function arguments
 
 ////////////////////////////////////
@@ -277 +301 @@
     unsigned int           lid;                // core local index for a thread
     unsigned int           n;                  // index in array to sort
-    pthread_t              trdid;              // kernel allocated thread index (unused)
     pthread_barrierattr_t  barrier_attr;       // barrier attributes
 
@@ -353 +376 @@
     // launch other threads to execute sort() function
     // on cores other than the core running the main thread
-    for ( x=0 ; x<x_size ; x++ )
-    {
-        for ( y=0 ; y<y_size ; y++ )
-        {
-            for ( lid=0 ; lid<ncores ; lid++ )
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            for ( lid = 0 ; lid < ncores ; lid++ )
             {
+                // compute thread user index (continuous index)
                 thread_uid = (((x * y_size) + y) * ncores) + lid;
 
-                // set sort arguments for all threads
+                // set arguments for all threads
                 arg[thread_uid].threads      = total_threads;
                 arg[thread_uid].thread_uid   = thread_uid;
@@ -367 +391 @@
 
                 // set thread attributes for all threads
-                attr[thread_uid].attributes = PT_ATTR_DETACH          |
-                                              PT_ATTR_CLUSTER_DEFINED | 
-                                              PT_ATTR_CORE_DEFINED;
+                attr[thread_uid].attributes = PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
                 attr[thread_uid].cxy        = HAL_CXY_FROM_XY( x , y );
                 attr[thread_uid].lid        = lid;
@@ -375 +397 @@
                 if( thread_uid != main_uid )
                 {
-                    if ( pthread_create( &trdid,              // not used because no join
+                    if ( pthread_create( &trdid[thread_uid],  // buffer for kernel identifier
                                          &attr[thread_uid],   // thread attributes 
                                          &sort,               // entry function 
@@ -383 +405 @@
                         exit( 0 );
                     }
-                    else
-                    {
-#if DEBUG_MAIN
+
+#if (DEBUG_MAIN & 1)
 printf("\n[sort] main created thread %x \n", thread_uid );
 #endif
-                    }
                 }
             }
@@ -402 +422 @@
 #endif
 
-#if INTERACTIVE_MODE
-idbg();
-#endif
-    
     // the main thread run also the sort() function
     sort( &arg[main_uid] );
 
+    // wait other threads completion
+    for ( x = 0 ; x < x_size ; x++ )
+    {
+        for ( y = 0 ; y < y_size ; y++ )
+        {
+            for ( lid = 0 ; lid < ncores ; lid++ )
+            {
+                // compute thread continuous index
+                thread_uid = (((x * y_size) + y) * ncores) + lid;
+
+                if( thread_uid != main_uid )
+                {
+                    if( pthread_join( trdid[thread_uid] , NULL ) )
+                    {
+                        printf("\n[fft error] in main thread %d joining thread %d\n",
+                        main_uid , thread_uid );
+                        exit( 0 );
+                    }
+                    
+#if (DEBUG_MAIN & 1)
+printf("\n[fft] main thread %d joined thread %d\n", main_uid, thread_uid );
+#endif
+
+                }
+            }
+        }
+    }
+
     ////////////////////////////
     get_cycle( &para_end_cycle );
@@ -417 +461 @@
     // destroy barrier
     pthread_barrier_destroy( &barrier );
-
-#if INTERACTIVE_MODE
-idbg();
-#endif
 
 #if CHECK_RESULT