Changes between Version 11 and Version 12 of user_applications

Timestamp:

Oct 16, 2015, 1:57:52 PM (10 years ago)

Author:

alain

Comment:

--

user_applications

@@ -156 +156 @@
 
 This multi-threaded application emulates a network processing application such as an
-ethernet router. All communications between threads use the  MWMR (Multi-Writer/Multi-Reader) channels middleware.
+ethernet router. All communications between threads use the  MWMR (multi-writer/multi-reader)  middleware.
 The application is described as a TCG (Task and communication Graph) :
- * The number of thread N is (x_size*y_size*nprocs): nprocs threads per clusters.
+ * The number N of thread is (x_size*y_size*nprocs): nprocs threads per clusters.
  * There is one producer() thread, one consumer() thread, and N-2 compute() threads.
  * The number M of MWMR channels is (2 * x_size * y_size) : one input and one output channel per cluster.
 
 It that can run on a multi-processors, multi-clusters architecture, with one thread per processor. 
-In this implementation, only integer token are transfered between threads, but they can be interpreted as job descriptors:
- * The main() thread, running on P[0,0,0], makes the initializations, and laugh the N other threads, and exit.
+In this implementation, only integer token are transfered between threads, but each token can be interpreted as a job descriptor:
+ * The main() thread, running on P[0,0,0], makes the initializations, launches the N other threads, and exit.
  * The producer() thread, running on P[0,0,0] try to write continuously tokens into the M distributed input channels using non-blocking write function.
  * The consumer() thread, running on P[0,0,1] try to read continuously tokens from the M distributed output channels, using a non-blocking read function.
- * The N-2 compute() threads running on all other processors are reading token  from the local input channel, and writing token to the local output channel, after a random delay emulating a variable processing time.
+ * The N-2 compute() threads running on all other processors are  continuously reading token  from the local input channel, and writing the same token to the local output channel, after a random delay emulating a variable processing time. They use blocking access functions.
 
 It require one TTY terminal shared by all threads.