Context Navigation

source: soft/giet_vm/applications/transpose/transpose.c @ 708

Last change on this file since 708 was 708, checked in by alain, 10 years ago

Adapt the following application to the POSIX threads API

convol
classif
raycast
coproc
display
gameoflife
transpose
shell

File size: 19.6 KB

Line
1	///////////////////////////////////////////////////////////////////////////////////////
2	// File : transpose.c
3	// Date : september 2015
4	// author : Alain Greiner
5	///////////////////////////////////////////////////////////////////////////////////////
6	// This multi-threaded aplication transposes a raw image (one pbyte per pixel).
7	// It can run on a multi-processors, multi-clusters architecture, with one thread
8	// per processor, and uses the POSIX threads API.
9	//
10	// The main() function can be launched on any processor P[x,y,l].
11	// It makes the initialisations, launch (N-1) threads to run the execute() function
12	// on the (N-1) other processors than P[x,y,l], call himself the execute() function,
13	// and finally call the instrument() function to display instrumentation results
14	// when the parallel execution is completed.
15	//
16	// The input and output buffers containing the image are distributed in clusters.
17	//
18	// The execute() function read a set of lines from an input file on disk,
19	// to the local buffer buf_in[x][y], transpose it, write the result to a remote buffer
20	// buf_out[x'][y'], display the content of the local buffer buf_out[x][y] to the
21	// frame buffer, and store it on disk to another output file.
22	//
23	// - The image size must fit the frame buffer size.
24	// - The block size in block device must be 512 bytes.
25	// - The number of clusters must be a power of 2 no larger than 256.
26	// - The number of processors per cluster must be a power of 2 no larger than 4.
27	///////////////////////////////////////////////////////////////////////////////////////
28
29	#include "stdio.h"
30	#include "user_barrier.h"
31	#include "malloc.h"
32
33	#define BLOCK_SIZE 512 // block size on disk
34	#define X_MAX 16 // max number of clusters in row
35	#define Y_MAX 16 // max number of clusters in column
36	#define PROCS_MAX 4 // max number of procs per cluster
37	#define CLUSTER_MAX (X_MAX * Y_MAX) // max number of clusters
38	#define IMAGE_SIZE 256 // image size : nlines = npixels
39	#define INPUT_FILE_PATH "/misc/lena_256.raw" // pathname on virtual disk
40	#define OUTPUT_FILE_PATH "/home/lena_transposed.raw" // pathname on virtual disk
41
42	// macro to use a shared TTY
43	#define printf(...); { lock_acquire( &tty_lock ); \
44	giet_tty_printf(__VA_ARGS__); \
45	lock_release( &tty_lock ); }
46
47	///////////////////////////////////////////////////////
48	// global variables stored in seg_data in cluster(0,0)
49	///////////////////////////////////////////////////////
50
51	// instrumentation counters for each processor in each cluster
52	unsigned int LOAD_START[X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
53	unsigned int LOAD_END [X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
54	unsigned int TRSP_START[X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
55	unsigned int TRSP_END [X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
56	unsigned int DISP_START[X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
57	unsigned int DISP_END [X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
58	unsigned int STOR_START[X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
59	unsigned int STOR_END [X_MAX][Y_MAX][PROCS_MAX] = {{{ 0 }}};
60
61	// arrays of pointers on distributed buffers
62	// one input buffer & one output buffer per cluster
63	unsigned char* buf_in [CLUSTER_MAX];
64	unsigned char* buf_out[CLUSTER_MAX];
65
66	// checksum variables
67	unsigned check_line_before[IMAGE_SIZE];
68	unsigned check_line_after[IMAGE_SIZE];
69
70	// lock protecting shared TTY
71	user_lock_t tty_lock;
72
73	// synchronisation barrier (all threads)
74	giet_sqt_barrier_t barrier;
75
76	////////////////////////////////////////////
77	__attribute__ ((constructor)) void execute()
78	////////////////////////////////////////////
79	{
80	unsigned int l; // line index for loops
81	unsigned int p; // pixel index for loops
82
83	// get processor identifiers
84	unsigned int x_id; // x cluster coordinate
85	unsigned int y_id; // y cluster coordinate
86	unsigned int p_id; // local processor index
87
88	giet_proc_xyp( &x_id, &y_id, &p_id);
89
90	// get & check plat-form parameters
91	unsigned int x_size; // number of clusters in a row
92	unsigned int y_size; // number of clusters in a column
93	unsigned int nprocs; // number of processors per cluster
94
95	giet_procs_number( &x_size , &y_size , &nprocs );
96
97	unsigned int nclusters = x_size * y_size; // number of clusters
98	unsigned int nthreads = x_size * y_size * nprocs; // number of threads
99	unsigned int npixels = IMAGE_SIZE * IMAGE_SIZE; // pixels per image
100	int fd_in = 0; // initial file descriptor
101	int fd_out = 0; // output file descriptor
102	unsigned int cluster_id = (x_id * y_size) + y_id; // "continuous" index
103	unsigned int thread_id = (cluster_id * nprocs) + p_id; // "continuous" thread index
104
105	// parallel load of image:
106	// allocate buf_in and buf_out distributed buffers (one buf_in & one buf_out per cluster).
107	// open input and output files, and load the relevant lines in local buf_in.
108	// only thread running on processor[x,y,0] does it.
109
110	LOAD_START[x_id][y_id][p_id] = giet_proctime();
111
112	if ( p_id == 0 )
113	{
114	buf_in[cluster_id] = remote_malloc( npixels/nclusters, x_id, y_id );
115	buf_out[cluster_id] = remote_malloc( npixels/nclusters, x_id, y_id );
116
117	if ( (x_id==0) && (y_id==0) )
118	{
119	printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes buffer allocation at cycle %d\n",
120	x_id, y_id, p_id, giet_proctime() );
121	}
122
123	// open input file
124	fd_in = giet_fat_open( INPUT_FILE_PATH , O_RDONLY ); // read_only
125	if ( fd_in < 0 )
126	{
127	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
128	x_id , y_id , p_id , INPUT_FILE_PATH );
129	giet_pthread_exit(" open() failure");
130	}
131	else if ( (x_id==0) && (y_id==0) )
132	{
133	printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
134	INPUT_FILE_PATH , fd_in );
135	}
136
137	// open output file
138	fd_out = giet_fat_open( OUTPUT_FILE_PATH , O_CREATE ); // create if required
139	if ( fd_out < 0 )
140	{
141	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot open file %s\n",
142	x_id , y_id , p_id , OUTPUT_FILE_PATH );
143	giet_pthread_exit(" open() failure");
144	}
145	else if ( (x_id==0) && (y_id==0) )
146	{
147	printf("\n[TRANSPOSE] Proc [0,0,0] open file %s / fd = %d\n",
148	OUTPUT_FILE_PATH , fd_out );
149	}
150
151
152	unsigned int offset = ((npixels*cluster_id)/nclusters);
153	if ( giet_fat_lseek( fd_in,
154	offset,
155	SEEK_SET ) != offset )
156	{
157	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fd = %d\n",
158	x_id , y_id , p_id , fd_in );
159	giet_pthread_exit(" seek() failure");
160	}
161
162	unsigned int pixels = npixels / nclusters;
163	if ( giet_fat_read( fd_in,
164	buf_in[cluster_id],
165	pixels ) != pixels )
166	{
167	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot read fd = %d\n",
168	x_id , y_id , p_id , fd_in );
169	giet_pthread_exit(" read() failure");
170	}
171
172	if ( (x_id==0) && (y_id==0) )
173	{
174	printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes load at cycle %d\n",
175	x_id, y_id, p_id, giet_proctime() );
176	}
177	}
178
179	LOAD_END[x_id][y_id][p_id] = giet_proctime();
180
181	/////////////////////////////
182	sqt_barrier_wait( &barrier );
183	/////////////////////////////
184
185	// parallel transpose from buf_in to buf_out
186	// each thread makes the transposition for nlt lines (nlt = IMAGE_SIZE/nthreads)
187	// from line [thread_idnlt] to line [(thread_id + 1)nlt - 1]
188	// (p,l) are the absolute pixel coordinates in the source image
189
190	TRSP_START[x_id][y_id][p_id] = giet_proctime();
191
192	unsigned int nlt = IMAGE_SIZE / nthreads; // number of lines per thread
193	unsigned int nlc = IMAGE_SIZE / nclusters; // number of lines per cluster
194
195	unsigned int src_cluster;
196	unsigned int src_index;
197	unsigned int dst_cluster;
198	unsigned int dst_index;
199
200	unsigned char byte;
201
202	unsigned int first = thread_id * nlt; // first line index for a given thread
203	unsigned int last = first + nlt; // last line index for a given thread
204
205	for ( l = first ; l < last ; l++ )
206	{
207	check_line_before[l] = 0;
208
209	// in each iteration we transfer one byte
210	for ( p = 0 ; p < IMAGE_SIZE ; p++ )
211	{
212	// read one byte from local buf_in
213	src_cluster = l / nlc;
214	src_index = (l % nlc)*IMAGE_SIZE + p;
215	byte = buf_in[src_cluster][src_index];
216
217	// compute checksum
218	check_line_before[l] = check_line_before[l] + byte;
219
220	// write one byte to remote buf_out
221	dst_cluster = p / nlc;
222	dst_index = (p % nlc)*IMAGE_SIZE + l;
223	buf_out[dst_cluster][dst_index] = byte;
224	}
225	}
226
227	if ( (p_id == 0) && (x_id==0) && (y_id==0) )
228	{
229	printf("\n[TRANSPOSE] proc [%d,%d,%d] completes transpose at cycle %d\n",
230	x_id, y_id, p_id, giet_proctime() );
231	}
232
233	TRSP_END[x_id][y_id][p_id] = giet_proctime();
234
235	/////////////////////////////
236	sqt_barrier_wait( &barrier );
237	/////////////////////////////
238
239	// parallel display from local buf_out to frame buffer
240	// all threads contribute to display using memcpy...
241
242	DISP_START[x_id][y_id][p_id] = giet_proctime();
243
244	unsigned int npt = npixels / nthreads; // number of pixels per thread
245
246	giet_fbf_sync_write( npt * thread_id,
247	&buf_out[cluster_id][p_id*npt],
248	npt );
249
250	if ( (x_id==0) && (y_id==0) && (p_id==0) )
251	{
252	printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes display at cycle %d\n",
253	x_id, y_id, p_id, giet_proctime() );
254	}
255
256	DISP_END[x_id][y_id][p_id] = giet_proctime();
257
258	/////////////////////////////
259	sqt_barrier_wait( &barrier );
260	/////////////////////////////
261
262	// parallel store : buf_out buffers to disk
263	// only thread running on processor(x,y,0) does it
264
265	STOR_START[x_id][y_id][p_id] = giet_proctime();
266
267	if ( p_id == 0 )
268	{
269	unsigned int offset = ((npixels*cluster_id)/nclusters);
270	if ( giet_fat_lseek( fd_out,
271	offset,
272	SEEK_SET ) != offset )
273	{
274	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot seek fr = %d\n",
275	x_id , y_id , p_id , fd_out );
276	giet_pthread_exit(" seek() failure");
277	}
278
279	unsigned int pixels = npixels / nclusters;
280	if ( giet_fat_write( fd_out,
281	buf_out[cluster_id],
282	pixels ) != pixels )
283	{
284	printf("\n[TRANSPOSE ERROR] Proc [%d,%d,%d] cannot write fd = %d\n",
285	x_id , y_id , p_id , fd_out );
286	giet_pthread_exit(" write() failure");
287	}
288
289	if ( (x_id==0) && (y_id==0) )
290	{
291	printf("\n[TRANSPOSE] Proc [%d,%d,%d] completes store at cycle %d\n",
292	x_id, y_id, p_id, giet_proctime() );
293	}
294	}
295
296	STOR_END[x_id][y_id][p_id] = giet_proctime();
297
298	// In each cluster, only thread running on Processor[x,y,0] releases
299	// the distributed buffers and close the file descriptors.
300
301	if ( p_id==0 )
302	{
303	free( buf_in[cluster_id] );
304	free( buf_out[cluster_id] );
305
306	giet_fat_close( fd_in );
307	giet_fat_close( fd_out );
308	}
309
310	if ( (x_id != 0) \|\| (y_id != 0) \|\| (p_id != 0) )
311	giet_pthread_exit( "completed" );
312
313	} // end execute()
314
315
316
317	//////////////////////////////////////
318	void instrument( unsigned int x_size,
319	unsigned int y_size,
320	unsigned int nprocs )
321	//////////////////////////////////////
322	{
323	unsigned int x, y, l;
324
325	unsigned int min_load_start = 0xFFFFFFFF;
326	unsigned int max_load_start = 0;
327	unsigned int min_load_ended = 0xFFFFFFFF;
328	unsigned int max_load_ended = 0;
329	unsigned int min_trsp_start = 0xFFFFFFFF;
330	unsigned int max_trsp_start = 0;
331	unsigned int min_trsp_ended = 0xFFFFFFFF;
332	unsigned int max_trsp_ended = 0;
333	unsigned int min_disp_start = 0xFFFFFFFF;
334	unsigned int max_disp_start = 0;
335	unsigned int min_disp_ended = 0xFFFFFFFF;
336	unsigned int max_disp_ended = 0;
337	unsigned int min_stor_start = 0xFFFFFFFF;
338	unsigned int max_stor_start = 0;
339	unsigned int min_stor_ended = 0xFFFFFFFF;
340	unsigned int max_stor_ended = 0;
341
342	for (x = 0; x < x_size; x++)
343	{
344	for (y = 0; y < y_size; y++)
345	{
346	for ( l = 0 ; l < nprocs ; l++ )
347	{
348	if (LOAD_START[x][y][l] < min_load_start) min_load_start = LOAD_START[x][y][l];
349	if (LOAD_START[x][y][l] > max_load_start) max_load_start = LOAD_START[x][y][l];
350	if (LOAD_END[x][y][l] < min_load_ended) min_load_ended = LOAD_END[x][y][l];
351	if (LOAD_END[x][y][l] > max_load_ended) max_load_ended = LOAD_END[x][y][l];
352	if (TRSP_START[x][y][l] < min_trsp_start) min_trsp_start = TRSP_START[x][y][l];
353	if (TRSP_START[x][y][l] > max_trsp_start) max_trsp_start = TRSP_START[x][y][l];
354	if (TRSP_END[x][y][l] < min_trsp_ended) min_trsp_ended = TRSP_END[x][y][l];
355	if (TRSP_END[x][y][l] > max_trsp_ended) max_trsp_ended = TRSP_END[x][y][l];
356	if (DISP_START[x][y][l] < min_disp_start) min_disp_start = DISP_START[x][y][l];
357	if (DISP_START[x][y][l] > max_disp_start) max_disp_start = DISP_START[x][y][l];
358	if (DISP_END[x][y][l] < min_disp_ended) min_disp_ended = DISP_END[x][y][l];
359	if (DISP_END[x][y][l] > max_disp_ended) max_disp_ended = DISP_END[x][y][l];
360	if (STOR_START[x][y][l] < min_stor_start) min_stor_start = STOR_START[x][y][l];
361	if (STOR_START[x][y][l] > max_stor_start) max_stor_start = STOR_START[x][y][l];
362	if (STOR_END[x][y][l] < min_stor_ended) min_stor_ended = STOR_END[x][y][l];
363	if (STOR_END[x][y][l] > max_stor_ended) max_stor_ended = STOR_END[x][y][l];
364	}
365	}
366	}
367
368	printf("\n ---------------- Instrumentation Results ---------------------\n");
369
370	printf(" - LOAD_START : min = %d / max = %d / med = %d / delta = %d\n",
371	min_load_start, max_load_start, (min_load_start+max_load_start)/2,
372	max_load_start-min_load_start);
373
374	printf(" - LOAD_END : min = %d / max = %d / med = %d / delta = %d\n",
375	min_load_ended, max_load_ended, (min_load_ended+max_load_ended)/2,
376	max_load_ended-min_load_ended);
377
378	printf(" - TRSP_START : min = %d / max = %d / med = %d / delta = %d\n",
379	min_trsp_start, max_trsp_start, (min_trsp_start+max_trsp_start)/2,
380	max_trsp_start-min_trsp_start);
381
382	printf(" - TRSP_END : min = %d / max = %d / med = %d / delta = %d\n",
383	min_trsp_ended, max_trsp_ended, (min_trsp_ended+max_trsp_ended)/2,
384	max_trsp_ended-min_trsp_ended);
385
386	printf(" - DISP_START : min = %d / max = %d / med = %d / delta = %d\n",
387	min_disp_start, max_disp_start, (min_disp_start+max_disp_start)/2,
388	max_disp_start-min_disp_start);
389
390	printf(" - DISP_END : min = %d / max = %d / med = %d / delta = %d\n",
391	min_disp_ended, max_disp_ended, (min_disp_ended+max_disp_ended)/2,
392	max_disp_ended-min_disp_ended);
393
394	printf(" - STOR_START : min = %d / max = %d / med = %d / delta = %d\n",
395	min_stor_start, max_stor_start, (min_stor_start+max_stor_start)/2,
396	max_stor_start-min_stor_start);
397
398	printf(" - STOR_END : min = %d / max = %d / med = %d / delta = %d\n",
399	min_stor_ended, max_stor_ended, (min_stor_ended+max_stor_ended)/2,
400	max_stor_ended-min_stor_ended);
401
402	} // end instrument()
403
404
405
406	//////////////////////////////////////////
407	__attribute__ ((constructor)) void main()
408	//////////////////////////////////////////
409	{
410	// indexes for loops
411	unsigned int x , y , n;
412
413	// get identifiers for proc executing main
414	unsigned int x_id; // x cluster coordinate
415	unsigned int y_id; // y cluster coordinate
416	unsigned int p_id; // local processor index
417
418	giet_proc_xyp( &x_id , &y_id , &p_id );
419
420	// get & check plat-form parameters
421	unsigned int x_size; // number of clusters in a row
422	unsigned int y_size; // number of clusters in a column
423	unsigned int nprocs; // number of processors per cluster
424
425	giet_procs_number( &x_size , &y_size , &nprocs );
426
427	giet_pthread_assert( ((nprocs == 1) \|\| (nprocs == 2) \|\| (nprocs == 4)),
428	"[TRANSPOSE ERROR] number of procs per cluster must be 1, 2 or 4");
429
430	giet_pthread_assert( ((x_size == 1) \|\| (x_size == 2) \|\| (x_size == 4) \|\|
431	(x_size == 8) \|\| (x_size == 16)),
432	"[TRANSPOSE ERROR] x_size must be 1,2,4,8,16");
433
434	giet_pthread_assert( ((y_size == 1) \|\| (y_size == 2) \|\| (y_size == 4) \|\|
435	(y_size == 8) \|\| (y_size == 16)),
436	"[TRANSPOSE ERROR] y_size must be 1,2,4,8,16");
437
438	giet_pthread_assert( (nprocs * x_size * y_size <= IMAGE_SIZE ),
439	"[TRANSPOSE ERROR] number of threads larger than number of lines");
440
441	unsigned int nthreads = x_size * y_size * nprocs;
442
443	// shared TTY allocation
444	giet_tty_alloc( 1 );
445	lock_init( &tty_lock);
446
447	printf("\n[TRANSPOSE] start at cycle %d on %d cores\n", giet_proctime(), nthreads );
448
449	// distributed heap initialisation
450	for ( x = 0 ; x < x_size ; x++ )
451	{
452	for ( y = 0 ; y < y_size ; y++ )
453	{
454	heap_init( x , y );
455	}
456	}
457
458	// allocate thread[] array
459	pthread_t* thread = malloc( nthreads * sizeof(pthread_t) );
460
461	// barrier initialisation
462	sqt_barrier_init( &barrier, x_size , y_size , nprocs );
463
464	// Initialisation completed
465	printf("\n[TRANSPOSE] initialisation completed at cycle %d\n", giet_proctime() );
466
467	// launch other threads to run execute() function
468	for ( n = 1 ; n < nthreads ; n++ )
469	{
470	if ( giet_pthread_create( &thread[n],
471	NULL, // no attribute
472	&execute,
473	NULL ) ) // no argument
474	{
475	printf("\n[TRANSPOSE ERROR] creating thread %x\n", thread[n] );
476	giet_pthread_exit( NULL );
477	}
478	}
479
480	// run the execute() function
481	execute();
482
483	// wait other threads completion
484	for ( n = 1 ; n < nthreads ; n++ )
485	{
486	if ( giet_pthread_join( thread[n], NULL ) )
487	{
488	printf("\n[TRANSPOSE ERROR] joining thread %x\n", thread[n] );
489	giet_pthread_exit( NULL );
490	}
491	else
492	{
493	printf("\n[TRANSPOSE] thread %x joined at cycle %d\n",
494	thread[n] , giet_proctime() );
495	}
496	}
497
498	// call the instrument() function
499	instrument( x_size , y_size , nprocs );
500
501	giet_pthread_exit( "completed" );
502
503	} // end main()
504

Note: See TracBrowser for help on using the repository browser.

Download in other formats: