+-------------------------+
|     INSTALLATION :      |
+-------------------------+

You need to compile on a SUN workstation with the directory 
/usr/demo/SOUND/
installed (need of the audio libraries). But you can run them 
on any SUN of the same type.
Compile with the makefile and use the programmes following 
the examples file.
Several input trace files are given in the TRF directory. 
They correspond to real applications, monitored on different 
parallel ditributed memory machines usibg the ParaGraph tool.


+-------------------------+
| MONITORING AND SOUNDS : |
+-------------------------+

tr_send :
~~~~~~~~~

/*
 * Trace analysis pipe (create a sound based on a trace file)
 *		J-Y Peterschmitt - 01/93
 *
 * tr_send.c
 * 
 * trace_file : stdin > tr_send nb length scale > stdout : sound
 *
 * nb		: number of processors
 * length	: number of sound samples generated for each event,
 *		  or each period of scale microseconds (execution time)
 * scale	: when there is no new event happening at the current 
 *		  time, we skip scale microseconds (execution time).
 *		  In fact, we play a "blank" sound (low frequency, low
 *		  intensity) of length samples.
 *
 * ==> scale microseconds of execution time (time described by the
 * timestamps in the trace file) will be associated with length sound
 * samples (a sound lasting length / SMP_RATE seconds)
 *
 * The program maps each of the nb processors to a unique frequency
 * (the highest proc number has the highest frequency).
 * Then, sequentially analyzing the input trace file, the program
 * plays the frequency associated with a processor, when this
 * processor starts sending a message. 
 *
 */

tr_sendmix :
~~~~~~~~~~~~

/*
 * Trace analysis pipe (create a sound based on a trace file)
 *		J-Y Peterschmitt - 02/93
 *
 * tr_sendmix.c
 * 
 * trace_file : stdin > tr_sendmix nb length scale > stdout : sound
 *
 * nb		: number of processors
 * length	: number of sound samples generated for each event,
 *		  or each period of scale microseconds (execution time)
 * scale	: when there is no new event happening at the current 
 *		  time, we skip scale microseconds (execution time).
 *		  In fact, we play a sound of length samples.
 *
 * ==> scale microseconds of execution time (time described by the
 * timestamps in the trace file) will be associated with length sound
 * samples (a sound lasting length / SMP_RATE seconds). When nothing
 * at all is happening, we play a "blank" sound (low frequency, low
 * intensity) of length samples.
 *
 * The program maps each of the nb processors to a unique frequency
 * (the highest proc number has the highest frequency).
 * Then, sequentially analyzing the input trace file, the program
 * plays the frequency associated with a processor, whenever this
 * processor has sent one or several messages, and that all these
 * messages have not yet been received. 
 * At a given time, we play simultaneously the frequencies associated
 * with all the currently sending processors.
 * We play a "sharper" tone when a processor starts sending a message.
 * The sound is louder when more processors are sending
 *
 */

tr_sendnum :
~~~~~~~~~~~~

/*
 * Trace analysis pipe (create a sound based on a trace file)
 *		J-Y Peterschmitt - 03/93
 *
 * tr_sendnum.c
 * 
 * trace_file : stdin > tr_sendnum nb length scale > stdout : sound
 *
 * nb		: maximum number of waiting messages
 * length	: number of sound samples generated for each event,
 *		  or each period of scale microseconds (execution time)
 * scale	: when there is no new event happening at the current 
 *		  time, we skip scale microseconds (execution time).
 *		  In fact, we play a sound of length samples.
 *
 * ==> scale microseconds of execution time (time described by the
 * timestamps in the trace file) will be associated with length sound
 * samples (a sound lasting length / SMP_RATE seconds). When nothing
 * at all is happening, we play a "blank" sound (low frequency, low
 * intensity) of length samples.
 *
 * The program maps the number of waiting messages (from 1 to nb) to
 * frequencies (from low to high frequencies). 
 * Then, sequentially analysing the input trace file, the program
 * plays the frequency associated with the current number of waiting
 * messages.
 *
 */

Examples :
~~~~~~~~~~

----------------------------------------------------------------------
chol.trf	Illustrates solution of linear system by Cholesky
		factorization, forward solution, and back substitution.
cat chol.trf | tr_send 8 400 20 | play
cat chol.trf | tr_sendmix 8 400 20 | play
cat chol.trf | tr_sendnum 20 400 20 | play

----------------------------------------------------------------------
exch.trf	Illustrates message exchanges in different hypercube
		dimensions.
cat exch.trf | tr_send 16 1500 20 | play
cat exch.trf | tr_sendmix 16 1500 20 | play
cat exch.trf | tr_sendnum 16 1500 20 | play

----------------------------------------------------------------------
fac.trf		Illustrates "task" displays, with each column of
		factorization a different task.
cat fac.trf | tr_send 8 1500 50 | play
cat fac.trf | tr_sendmix 8 1500 50 | play
cat fac.trf | tr_sendnum 14 1500 50 | play

----------------------------------------------------------------------
fans.trf	Illustrates four different ways of doing fan-out
		(broadcast) and fan-in (combine) global communication.
cat fans.trf | tr_send 16 400 10 | play
cat fans.trf | tr_sendmix 16 400 10 | play
cat fans.trf | tr_sendnum 16 400 10 | play

----------------------------------------------------------------------
fft.trf		Typical dimensional exchange pattern of an FFT.  Good
		for illustrating Spacetime, Animation, Comm Matrix,
		and various layouts in Hypercube display.  Also shows
		difference use of Gray code ordering makes.
cat fft.trf | tr_send 16 1500 30 | play
cat fft.trf | tr_sendmix 16 1500 30 | play
cat fft.trf | tr_sendnum 16 1500 30 | play

----------------------------------------------------------------------
fft64.trf	Same, but using more processors.
cat fft64.trf | tr_send 64 1500 30 | play
cat fft64.trf | tr_sendmix 64 1500 30 | play
cat fft64.trf | tr_sendnum 64 1500 30 | play

----------------------------------------------------------------------
flops.trf	Illustrates application-specific display for counting
		(flops in this case).
cat flops.trf | tr_send 8 400 10 | play
cat flops.trf | tr_sendmix 8 400 10 | play
cat flops.trf | tr_sendnum 42 400 10 | play

----------------------------------------------------------------------
matrix.trf	Illustrates application-specific display for matrix
		computations
cat matrix.trf | tr_send 16 1500 30 | play
cat matrix.trf | tr_sendmix 16 1500 30 | play
cat matrix.trf | tr_sendnum 16 1500 30 | play

----------------------------------------------------------------------
shuffle.trf	Illustrates "shuffle-exchange" layout of Hypercube
		display.
cat shuffle.trf | tr_send 16 1500 30 | play
cat shuffle.trf | tr_sendmix 16 1500 30 | play
cat shuffle.trf | tr_sendnum 16 1500 30 | play

----------------------------------------------------------------------
sort.trf	Illustrates application-specific display for sorting
cat sort.trf | tr_send 16 1500 50 | play
cat sort.trf | tr_sendmix 16 1500 50 | play
cat sort.trf | tr_sendnum 16 1500 50 | play

----------------------------------------------------------------------
sparse.trf	Sparse Cholesky factorization; illustrates typical
		pattern of a divide-and-conquer parallel algorithm
		based on nested dissection ordering of grid.  This
		example was used to create most of the illustrations
		for the IEEE Software paper and tech report on
		ParaGraph.
cat sparse.trf | tr_send 8 1500 100 | play
cat sparse.trf | tr_sendmix 8 1500 100 | play
cat sparse.trf | tr_sendnum 15 1500 100 | play

----------------------------------------------------------------------
transpose.trf	Illustrates application-specific display for
		transposition
cat transpose.trf | tr_send 16 1500 10 | play
cat transpose.trf | tr_sendmix 16 1500 10 | play
cat transpose.trf | tr_sendnum 16 1500 10 | play
