Annotation of /trunk/uoms/src/init.upc

Parent Directory | Revision Log

---

Revision 23 - (view) (download)

1 :	dalvarez	14	/******************************************************************************/
2 :			/* */
3 :			/* Copyright (c) 2008, 2009, 2010 */
4 :			/* Computer Architecture Group (CAG) */
5 :			/* University of A Coruña, Spain */
6 :			/* (http://gac.des.udc.es) */
7 :			/* Galicia Supercomputing Center (CESGA) */
8 :			/* (http://www.cesga.es) */
9 :			/* Hewlett-Packard Spain (HP) */
10 :			/* (http://www.hp.es) */
11 :			/* */
12 :			/* This file is part of UPC Operations Microbenchmarking Suite (UOMS). */
13 :			/* */
14 :			/* UOMS is free software: you can redistribute it and/or modify */
15 :			/* it under the terms of the GNU Lesser General Public License as published */
16 :			/* by the Free Software Foundation, either version 3 of the License, or */
17 :			/* (at your option) any later version. */
18 :			/* */
19 :			/* UOMS is distributed in the hope that it will be useful, */
20 :			/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
21 :			/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
22 :			/* GNU Lesser General Public License for more details. */
23 :			/* */
24 :			/* You should have received a copy of the GNU Lesser General Public License */
25 :			/* along with UOMS. If not, see <http://www.gnu.org/licenses/>. */
26 :			/* */
27 :			/******************************************************************************/
28 :	dalvarez	1
29 :	dalvarez	14	/******************************************************************************/
30 :			/* */
31 :			/* FUNDING: This development has been funded by Hewlett-Packard Spain */
32 :			/* */
33 :			/* Project Name: */
34 :			/* UPCHACO (2008-2011) */
35 :			/* Subproject: */
36 :			/* Improving UPC Usability and Performance in Constellation Systems: */
37 :			/* Implementation/Extensions of UPC Libraries. */
38 :			/* (UPCPUProject -> UPC Performance and Usability Project) */
39 :			/* */
40 :			/******************************************************************************/
41 :	dalvarez	1
42 :	dalvarez	14	/******************************************************************************
43 :	dalvarez	1
44 :			For further documentation, see
45 :
46 :			[1] Files under doc/
47 :
48 :	dalvarez	14	*******************************************************************************/
49 :	dalvarez	1
50 :			#include <stdio.h>
51 :			#include <stdlib.h>
52 :			#include <math.h>
53 :			#include <errno.h>
54 :			#include <string.h>
55 :			#include <upc_collective.h>
56 :			#include "defines.h"
57 :			#include "headers.h"
58 :
59 :			#define roundtoint(x) ((x)>=0?(int)((x)+0.5):(int)((x)-0.5))
60 :
61 :			extern char * valid_bms[NUM_BMS];
62 :			extern upc_op_t reduce_op;
63 :	dalvarez	15	extern uint64_t timeLimit;
64 :	dalvarez	1
65 :			long maxsize, minsize;
66 :
67 :			/*
68 :			Set benchmarks names
69 :			*/
70 :			void set_bms_names(){
71 :	dalvarez	15	valid_bms[FORALL_R] = "upc_forall_read";
72 :			valid_bms[FORALL_W] = "upc_forall_write";
73 :			valid_bms[FORALL_RW] = "upc_forall_readwrite";
74 :			valid_bms[FOR_R] = "for_read";
75 :			valid_bms[FOR_W] = "for_write";
76 :			valid_bms[FOR_RW] = "for_readwrite";
77 :	dalvarez	1	valid_bms[BARRIER] = "upc_barrier";
78 :			valid_bms[BROADCAST] = "upc_all_broadcast";
79 :			valid_bms[SCATTER] = "upc_all_scatter";
80 :			valid_bms[GATHER] = "upc_all_gather";
81 :			valid_bms[GATHERALL] = "upc_all_gather_all";
82 :			valid_bms[EXCHANGE] = "upc_all_exchange";
83 :			valid_bms[PERMUTE] = "upc_all_permute";
84 :			valid_bms[MEMGET] = "upc_memget";
85 :			valid_bms[MEMPUT] = "upc_memput";
86 :			valid_bms[MEMCPY] = "upc_memcpy";
87 :			valid_bms[LMEMGET] = "local_upc_memget";
88 :			valid_bms[LMEMPUT] = "local_upc_memput";
89 :			valid_bms[LMEMCPY] = "local_upc_memcpy";
90 :			valid_bms[SMEMCPY] = "memcpy";
91 :			valid_bms[MEMMOVE] = "memmove";
92 :			valid_bms[ALLALLOC] = "upc_all_alloc";
93 :			valid_bms[FREE] = "upc_free";
94 :			valid_bms[REDUCE_C] = "upc_all_reduceC";
95 :			valid_bms[PREFIX_REDUCE_C] = "upc_all_prefix_reduceC";
96 :			valid_bms[REDUCE_UC] = "upc_all_reduceUC";
97 :			valid_bms[PREFIX_REDUCE_UC] = "upc_all_prefix_reduceUC";
98 :			valid_bms[REDUCE_S] = "upc_all_reduceS";
99 :			valid_bms[PREFIX_REDUCE_S] = "upc_all_prefix_reduceS";
100 :			valid_bms[REDUCE_US] = "upc_all_reduceUS";
101 :			valid_bms[PREFIX_REDUCE_US] = "upc_all_prefix_reduceUS";
102 :			valid_bms[REDUCE_I] = "upc_all_reduceI";
103 :			valid_bms[PREFIX_REDUCE_I] = "upc_all_prefix_reduceI";
104 :			valid_bms[REDUCE_UI] = "upc_all_reduceUI";
105 :			valid_bms[PREFIX_REDUCE_UI] = "upc_all_prefix_reduceUI";
106 :			valid_bms[REDUCE_L] = "upc_all_reduceL";
107 :			valid_bms[PREFIX_REDUCE_L] = "upc_all_prefix_reduceL";
108 :			valid_bms[REDUCE_UL] = "upc_all_reduceUL";
109 :			valid_bms[PREFIX_REDUCE_UL] = "upc_all_prefix_reduceUL";
110 :			valid_bms[REDUCE_F] = "upc_all_reduceF";
111 :			valid_bms[PREFIX_REDUCE_F] = "upc_all_prefix_reduceF";
112 :			valid_bms[REDUCE_D] = "upc_all_reduceD";
113 :			valid_bms[PREFIX_REDUCE_D] = "upc_all_prefix_reduceD";
114 :			valid_bms[REDUCE_LD] = "upc_all_reduceLD";
115 :			valid_bms[PREFIX_REDUCE_LD] = "upc_all_prefix_reduceLD";
116 :			#ifdef ASYNC_MEM_TEST
117 :	dalvarez	7	valid_bms[AMEMGET] = "upc_memget_async";
118 :			valid_bms[AMEMPUT] = "upc_memput_async";
119 :			valid_bms[AMEMCPY] = "upc_memcpy_async";
120 :			valid_bms[ALMEMGET] = "local_upc_memget_async";
121 :			valid_bms[ALMEMPUT] = "local_upc_memput_async";
122 :			valid_bms[ALMEMCPY] = "local_upc_memcpy_async";
123 :	dalvarez	1	#endif
124 :	dalvarez	7	#ifdef ASYNCI_MEM_TEST
125 :			valid_bms[AIMEMGET] = "upc_memget_asynci";
126 :			valid_bms[AIMEMPUT] = "upc_memput_asynci";
127 :			valid_bms[AIMEMCPY] = "upc_memcpy_asynci";
128 :			valid_bms[AILMEMGET] = "local_upc_memget_asynci";
129 :			valid_bms[AILMEMPUT] = "local_upc_memput_asynci";
130 :			valid_bms[AILMEMCPY] = "local_upc_memcpy_asynci";
131 :			#endif
132 :	dalvarez	1	}
133 :
134 :			/*
135 :			Set min size
136 :			*/
137 :			int set_min_size(char *size){
138 :			if(size[0] >= '0' && size[0] <= '9'){
139 :			errno = 0;
140 :			minsize = strtol(size,NULL,10);
141 :			if(errno != 0){
142 :			if(MYTHREAD == 0){
143 :			fprintf(stderr,"*** minsize (%s) not valid: ",size);
144 :			perror(NULL);
145 :			}
146 :			return -1;
147 :			}
148 :			}
149 :			else{
150 :			if(MYTHREAD == 0){
151 :			fprintf(stderr,"*** minsize (%s) not valid",size);
152 :			}
153 :			return -1;
154 :			}
155 :			return 0;
156 :			}
157 :
158 :			/*
159 :			Set max size
160 :			*/
161 :			int set_max_size(char *size){
162 :			if(size[0] >= '0' && size[0] <= '9'){
163 :			errno = 0;
164 :			maxsize = strtol(size,NULL,10);
165 :			if(errno != 0){
166 :			if(MYTHREAD == 0){
167 :			fprintf(stderr,"*** maxsize (%s) not valid: ",size);
168 :			perror(NULL);
169 :			}
170 :			return -1;
171 :			}
172 :			}
173 :			else{
174 :			if(MYTHREAD == 0){
175 :			fprintf(stderr,"*** maxsize (%s) not valid",size);
176 :			}
177 :			return -1;
178 :			}
179 :			return 0;
180 :			}
181 :
182 :			/*
183 :	dalvarez	15	Set time limit
184 :			*/
185 :			int set_time_limit(char *time_limit){
186 :			if(time_limit[0] >= '0' && time_limit[0] <= '9'){
187 :			errno = 0;
188 :			timeLimit = strtol(time_limit,NULL,10);
189 :			if(errno != 0){
190 :			if(MYTHREAD == 0){
191 :			fprintf(stderr,"*** Time limit (%s) not valid: ",time_limit);
192 :			perror(NULL);
193 :			}
194 :			return -1;
195 :			}
196 :			}
197 :			else{
198 :			if(MYTHREAD == 0){
199 :			fprintf(stderr,"*** Time limit (%s) not valid",time_limit);
200 :			}
201 :			return -1;
202 :			}
203 :			return 0;
204 :			}
205 :
206 :			/*
207 :	dalvarez	1	Set reduce operation
208 :			*/
209 :			int set_reduce_op(char *operation){
210 :			extern char *char_reduce_op;
211 :
212 :			if(strcmp(operation,"UPC_ADD") == 0){
213 :			reduce_op = UPC_ADD;
214 :			char_reduce_op = operation;
215 :			}
216 :			else if(strcmp(operation,"UPC_MULT") == 0){
217 :			reduce_op = UPC_MULT;
218 :			char_reduce_op = operation;
219 :			}
220 :			else if(strcmp(operation,"UPC_AND") == 0){
221 :			reduce_op = UPC_AND;
222 :			char_reduce_op = operation;
223 :			}
224 :			else if(strcmp(operation,"UPC_OR") == 0){
225 :			reduce_op = UPC_OR;
226 :			char_reduce_op = operation;
227 :			}
228 :			else if(strcmp(operation,"UPC_XOR") == 0){
229 :			reduce_op = UPC_XOR;
230 :			char_reduce_op = operation;
231 :			}
232 :			else if(strcmp(operation,"UPC_LOGAND") == 0){
233 :			reduce_op = UPC_LOGAND;
234 :			char_reduce_op = operation;
235 :			}
236 :			else if(strcmp(operation,"UPC_LOGOR") == 0){
237 :			reduce_op = UPC_LOGOR;
238 :			char_reduce_op = operation;
239 :			}
240 :			else if(strcmp(operation,"UPC_MIN") == 0){
241 :			reduce_op = UPC_MIN;
242 :			char_reduce_op = operation;
243 :			}
244 :			else if(strcmp(operation,"UPC_MAX") == 0){
245 :			reduce_op = UPC_MAX;
246 :			char_reduce_op = operation;
247 :			}
248 :			else{
249 :			return -1;
250 :			}
251 :			return 0;
252 :			}
253 :
254 :			/*
255 :			Set synchronization mode
256 :			*/
257 :			int set_sync_mode(char *mode){
258 :			extern upc_flag_t sync_mode;
259 :			extern char * char_sync_mode;
260 :
261 :			if(strcmp(mode,"UPC_IN_ALLSYNC|UPC_OUT_ALLSYNC") == 0){
262 :			sync_mode = UPC_IN_ALLSYNC|UPC_OUT_ALLSYNC;
263 :			char_sync_mode = mode;
264 :			}
265 :			else if(strcmp(mode,"UPC_IN_ALLSYNC|UPC_OUT_MYSYNC") == 0){
266 :			sync_mode = UPC_IN_ALLSYNC|UPC_OUT_MYSYNC;
267 :			char_sync_mode = mode;
268 :			}
269 :			else if(strcmp(mode,"UPC_IN_ALLSYNC|UPC_OUT_NOSYNC") == 0){
270 :			sync_mode = UPC_IN_ALLSYNC|UPC_OUT_NOSYNC;
271 :			char_sync_mode = mode;
272 :			}
273 :			else if(strcmp(mode,"UPC_IN_MYSYNC|UPC_OUT_ALLSYNC") == 0){
274 :			sync_mode = UPC_IN_MYSYNC|UPC_OUT_ALLSYNC;
275 :			char_sync_mode = mode;
276 :			}
277 :			else if(strcmp(mode,"UPC_IN_MYSYNC|UPC_OUT_MYSYNC") == 0){
278 :			sync_mode = UPC_IN_MYSYNC|UPC_OUT_MYSYNC;
279 :			char_sync_mode = mode;
280 :			}
281 :			else if(strcmp(mode,"UPC_IN_MYSYNC|UPC_OUT_NOSYNC") == 0){
282 :			sync_mode = UPC_IN_MYSYNC|UPC_OUT_NOSYNC;
283 :			char_sync_mode = mode;
284 :			}
285 :			else if(strcmp(mode,"UPC_IN_NOSYNC|UPC_OUT_ALLSYNC") == 0){
286 :			sync_mode = UPC_IN_NOSYNC|UPC_OUT_ALLSYNC;
287 :			char_sync_mode = mode;
288 :			}
289 :			else if(strcmp(mode,"UPC_IN_NOSYNC|UPC_OUT_MYSYNC") == 0){
290 :			sync_mode = UPC_IN_NOSYNC|UPC_OUT_MYSYNC;
291 :			char_sync_mode = mode;
292 :			}
293 :			else if(strcmp(mode,"UPC_IN_NOSYNC|UPC_OUT_NOSYNC") == 0){
294 :			sync_mode = UPC_IN_NOSYNC|UPC_OUT_NOSYNC;
295 :			char_sync_mode = mode;
296 :			}
297 :			else{
298 :			return -1;
299 :			}
300 :			return 0;
301 :			}
302 :
303 :			/*
304 :			Set benchmark list
305 :			*/
306 :			void set_bms(int alternative_bm_list, char *bm_file){
307 :			extern int *bm_list;
308 :			extern int num_bms;
309 :			FILE *fd;
310 :
311 :			/*
312 :			Default procedure
313 :			*/
314 :			if(alternative_bm_list == 0){
315 :			num_bms = NUM_BMS;
316 :			errno = 0;
317 :			bm_list = malloc(num_bms*sizeof(int));
318 :			if(errno != 0){
319 :			if(MYTHREAD == 0){
320 :	dalvarez	14	/*
321 :			Just in case you want to run the benchmark in a toaster or someone/something steal all your memory ;-)
322 :			*/
323 :	dalvarez	1	fprintf(stderr,"*** Unable to allocate %ld bytes for benchmark list storing: ",num_bms*sizeof(int));
324 :			perror(NULL);
325 :			}
326 :			upc_barrier;
327 :			exit(-1);
328 :			}
329 :
330 :			int j = 0;
331 :			for(int i = 0; i < num_bms; i++){
332 :			if(reduce_op == UPC_AND || reduce_op == UPC_OR || reduce_op == UPC_XOR){
333 :			if(i == REDUCE_F || i == PREFIX_REDUCE_F || i == REDUCE_D || i == PREFIX_REDUCE_D || i == REDUCE_LD || i == PREFIX_REDUCE_LD){
334 :			continue;
335 :			}
336 :			}
337 :			bm_list[j] = i;
338 :			j++;
339 :			}
340 :
341 :			}
342 :
343 :			/*
344 :			User defined
345 :			*/
346 :			else{
347 :			if(bm_file == NULL){
348 :			if(MYTHREAD == 0){
349 :			fprintf(stderr,"Unexpected error when parsing the benchmarks list file\n");
350 :			}
351 :			upc_barrier;
352 :			exit(-1);
353 :			}
354 :
355 :			errno = 0;
356 :			fd = fopen(bm_file,"r");
357 :			if(errno != 0){
358 :			if(MYTHREAD == 0){
359 :			fprintf(stderr,"*** Error opening file %s: ",bm_file);
360 :			perror(NULL);
361 :			}
362 :			upc_barrier;
363 :			exit(-1);
364 :			}
365 :
366 :			char curbm[30];
367 :
368 :			/*
369 :			Two phases: one for get the number of benchmarks and the other to actually store them
370 :			*/
371 :			while (!feof(fd) && fgets(curbm, 30, fd)) {
372 :			for(int i = 0; i < 30; i++){
373 :			if(curbm[i] == '\n' || curbm[i] == ' '){
374 :			curbm[i] = '\0';
375 :			}
376 :			}
377 :			for(int i = 0; i < NUM_BMS; i++){
378 :			if(strcmp(curbm,valid_bms[i]) == 0){
379 :			num_bms++;
380 :			}
381 :			}
382 :			}
383 :			errno = 0;
384 :			rewind(fd);
385 :			if(errno != 0){
386 :			if(MYTHREAD == 0){
387 :			fprintf(stderr,"*** Error reading file %s: ",bm_file);
388 :			perror(NULL);
389 :			}
390 :			upc_barrier;
391 :			exit(-1);
392 :			}
393 :			errno = 0;
394 :			bm_list = malloc(num_bms*sizeof(int));
395 :			if(errno != 0){
396 :			if(MYTHREAD == 0){
397 :	dalvarez	14	/*
398 :			Just in case you want to run the benchmark in a toaster or someone/something steal all your memory ;-)
399 :			*/
400 :	dalvarez	1	fprintf(stderr,"*** Unable to allocate %ld bytes for benchmark list storing: ",num_bms*sizeof(int));
401 :			perror(NULL);
402 :			}
403 :			upc_barrier;
404 :			exit(-1);
405 :			}
406 :			int i = 0;
407 :			while (!feof(fd) && fgets(curbm, 30, fd)) {
408 :	dalvarez	7	for(int j = 0; j < 30; j++){
409 :			if(curbm[j] == '\n' || curbm[j] == ' '){
410 :			curbm[j] = '\0';
411 :	dalvarez	1	}
412 :			}
413 :			for(int j = 0; j < NUM_BMS; j++){
414 :			errno = 0;
415 :			if(strcmp(curbm,valid_bms[j]) == 0){
416 :			if(errno != 0){
417 :			if(MYTHREAD == 0){
418 :			fprintf(stderr,"*** Error parsing %s in file %s: ",curbm,bm_file);
419 :			perror(NULL);
420 :			}
421 :			upc_barrier;
422 :			exit(-1);
423 :			}
424 :			bm_list[i] = j;
425 :			i++;
426 :			}
427 :			}
428 :			}
429 :
430 :			fclose(fd);
431 :
432 :			}
433 :
434 :			if(num_bms < 1){
435 :			if(MYTHREAD == 0)
436 :			fprintf(stderr,"*** No valid benchmarks specified\n");
437 :			exit(-1);
438 :			}
439 :
440 :			}
441 :
442 :			/*
443 :			Set problem sizes
444 :			*/
445 :			void set_sizes(int alternative_sizes, char *sizes_file){
446 :			extern long *sizes;
447 :			extern int num_sizes;
448 :			FILE *fd;
449 :
450 :			/*
451 :			Default procedure
452 :			*/
453 :			if(alternative_sizes == 0){
454 :			num_sizes = roundtoint(log2((double)maxsize)) - roundtoint(log2((double)minsize)) + 1;
455 :			errno = 0;
456 :			sizes = malloc(num_sizes*sizeof(long));
457 :			if(errno != 0){
458 :			if(MYTHREAD == 0){
459 :			fprintf(stderr,"*** Unable to allocate %ld bytes for message sizes storing: ",num_sizes*sizeof(int));
460 :			perror(NULL);
461 :			}
462 :			upc_barrier;
463 :			exit(-1);
464 :			}
465 :
466 :			sizes[0] = minsize;
467 :
468 :			for(int i = 1; i < num_sizes; i++){
469 :			sizes[i] = sizes[i-1]*2;
470 :			}
471 :
472 :			if(sizes[num_sizes-1] > maxsize){
473 :	dalvarez	14	num_sizes--; // We waste sizeof(long) bytes, but probably we can afford it
474 :	dalvarez	1	}
475 :
476 :			}
477 :
478 :			/*
479 :			User defined
480 :			*/
481 :			else{
482 :			if(sizes_file == NULL){
483 :			if(MYTHREAD == 0){
484 :			fprintf(stderr,"Unexpected error when parsing the problem sizes file\n");
485 :			}
486 :			upc_barrier;
487 :			exit(-1);
488 :			}
489 :
490 :			errno = 0;
491 :			fd = fopen(sizes_file,"r");
492 :			if(errno != 0){
493 :			if(MYTHREAD == 0){
494 :			fprintf(stderr,"*** Error opening file %s: ",sizes_file);
495 :			perror(NULL);
496 :			}
497 :			upc_barrier;
498 :			exit(-1);
499 :			}
500 :
501 :			char cursize[20];
502 :
503 :			/*
504 :			Two phases: one for get the number of sizes and the other to actually store them
505 :			*/
506 :			while (!feof(fd) && fgets(cursize, 20, fd)) {
507 :			if(cursize[0] >= '0' && cursize[0] <= '9'){
508 :			errno = 0;
509 :	dalvarez	7	strtol(cursize,NULL,10);
510 :	dalvarez	1	if(errno != 0){
511 :			if(MYTHREAD == 0){
512 :			fprintf(stderr,"*** Error parsing %s in file %s: ",cursize,sizes_file);
513 :			perror(NULL);
514 :			}
515 :			upc_barrier;
516 :			exit(-1);
517 :			}
518 :			num_sizes++;
519 :			}
520 :			else{ /* Silently ignores other lines */
521 :			continue;
522 :			}
523 :			}
524 :			errno = 0;
525 :			rewind(fd);
526 :			if(errno != 0){
527 :			if(MYTHREAD == 0){
528 :			fprintf(stderr,"*** Error reading file %s: ",sizes_file);
529 :			perror(NULL);
530 :			}
531 :			upc_barrier;
532 :			exit(-1);
533 :			}
534 :			errno = 0;
535 :			sizes = malloc(num_sizes*sizeof(long));
536 :			if(errno != 0){
537 :			if(MYTHREAD == 0){
538 :			fprintf(stderr,"*** Unable to allocate %ld bytes for message sizes storing: ",num_sizes*sizeof(int));
539 :			perror(NULL);
540 :			}
541 :			upc_barrier;
542 :			exit(-1);
543 :			}
544 :			int i = 0;
545 :			while (!feof(fd) && fgets(cursize, 20, fd)) {
546 :			if(cursize[0] >= '0' && cursize[0] <= '9'){
547 :			errno = 0;
548 :			sizes[i] = strtol(cursize,NULL,10);
549 :			if(errno != 0){
550 :			if(MYTHREAD == 0){
551 :			fprintf(stderr,"*** Error parsing %s in file %s: ",cursize,sizes_file);
552 :			perror(NULL);
553 :			}
554 :			upc_barrier;
555 :			exit(-1);
556 :			}
557 :			i++;
558 :			}
559 :			else{ /* Silently ignores other lines */
560 :			continue;
561 :			}
562 :			}
563 :
564 :			fclose(fd);
565 :
566 :			}
567 :
568 :			if(num_sizes < 1){
569 :			if(MYTHREAD == 0)
570 :			fprintf(stderr,"*** No block sizes specified\n");
571 :			exit(-1);
572 :			}
573 :
574 :			}
575 :
576 :			// Init functions. E.g., initialize permutation array
577 :			void UOMS_init(){
578 :
579 :			int i;
580 :	dalvarez	15	extern shared int perm[THREADS]; //for permutation
581 :	dalvarez	1
582 :			//set the permutation array
583 :			if ( MYTHREAD == 0 )
584 :			{
585 :			for (i=0; i<THREADS; ++i)
586 :			perm[i] = i;
587 :			for (i=THREADS-1; i>0; --i)
588 :			{
589 :			int j = ((int)rand() >> 3) % i;
590 :			int tmp = perm[i];
591 :			perm[i] = perm[j];
592 :			perm[j] = tmp;
593 :			}
594 :			}
595 :			}
596 :
597 :			void init(int argc, char **argv){
598 :			extern FILE *unit;
599 :			extern int cache_invalidation;
600 :			extern int warmup;
601 :			char *sizes_file = NULL;
602 :			char *output_file = NULL;
603 :			char *bm_file = NULL;
604 :			int alternative_output_file = 0;
605 :			int alternative_sizes = 0;
606 :			int alternative_bm_list = 0;
607 :			minsize = MINSIZE;
608 :			maxsize = MAXSIZE;
609 :	dalvarez	15	extern int time_limit_set;
610 :	dalvarez	1
611 :			warmup = 0; // Defaults to off
612 :
613 :			set_bms_names();
614 :
615 :			/*
616 :			Command line arguments parsing
617 :			*/
618 :			for(int i = 1; i < argc; i++){
619 :			if(strcmp(argv[i],"-off_cache") == 0){
620 :			cache_invalidation = 1;
621 :			}
622 :			else if(strcmp(argv[i],"-msglen") == 0){
623 :			i++;
624 :			if(i == argc){
625 :			if(MYTHREAD == 0)
626 :			print_usage(argv[0]);
627 :			exit(-1);
628 :			}
629 :			else{
630 :			alternative_sizes = 1;
631 :			sizes_file = argv[i];
632 :			}
633 :			}
634 :			else if(strcmp(argv[i],"-input") == 0){
635 :			i++;
636 :			if(i == argc){
637 :			if(MYTHREAD == 0)
638 :			print_usage(argv[0]);
639 :			upc_barrier;
640 :			exit(-1);
641 :			}
642 :			else{
643 :			alternative_bm_list = 1;
644 :			bm_file = argv[i];
645 :			}
646 :			}
647 :			else if(strcmp(argv[i],"-reduce_op") == 0){
648 :			i++;
649 :			if(i == argc){
650 :			if(MYTHREAD == 0)
651 :			print_usage(argv[0]);
652 :			exit(-1);
653 :			}
654 :			else{
655 :			if(set_reduce_op(argv[i]) != 0){
656 :			if(MYTHREAD == 0)
657 :			print_usage(argv[0]);
658 :			exit(-1);
659 :			}
660 :			}
661 :			}
662 :			else if(strcmp(argv[i],"-sync_mode") == 0){
663 :			i++;
664 :			if(i == argc){
665 :			if(MYTHREAD == 0)
666 :			print_usage(argv[0]);
667 :			exit(-1);
668 :			}
669 :			else{
670 :			if(set_sync_mode(argv[i]) != 0){
671 :			if(MYTHREAD == 0)
672 :			print_usage(argv[0]);
673 :			exit(-1);
674 :			}
675 :			}
676 :			}
677 :			else if(strcmp(argv[i],"-minsize") == 0){
678 :			i++;
679 :			if(i == argc){
680 :			if(MYTHREAD == 0)
681 :			print_usage(argv[0]);
682 :			exit(-1);
683 :			}
684 :			else{
685 :			if(set_min_size(argv[i]) != 0){
686 :			if(MYTHREAD == 0)
687 :			print_usage(argv[0]);
688 :			exit(-1);
689 :			}
690 :			}
691 :			}
692 :			else if(strcmp(argv[i],"-maxsize") == 0){
693 :			i++;
694 :			if(i == argc){
695 :			if(MYTHREAD == 0)
696 :			print_usage(argv[0]);
697 :			exit(-1);
698 :			}
699 :			else{
700 :			if(set_max_size(argv[i]) != 0){
701 :			if(MYTHREAD == 0)
702 :			print_usage(argv[0]);
703 :			exit(-1);
704 :			}
705 :			}
706 :			}
707 :			else if(strcmp(argv[i],"-warmup") == 0){
708 :			warmup = 1;
709 :			}
710 :			else if(strcmp(argv[i],"-help") == 0){
711 :			if(MYTHREAD == 0)
712 :			print_usage(argv[0]);
713 :			upc_barrier;
714 :			exit(-1);
715 :			}
716 :			else if(strcmp(argv[i],"-version") == 0){
717 :			if(MYTHREAD == 0)
718 :			print_version();
719 :			upc_barrier;
720 :			exit(-1);
721 :			}
722 :	dalvarez	15	else if(strcmp(argv[i],"-time") == 0){
723 :			i++;
724 :			if(i == argc){
725 :			if(MYTHREAD == 0)
726 :			print_usage(argv[0]);
727 :			exit(-1);
728 :			}
729 :			else{
730 :			if(set_time_limit(argv[i]) != 0){
731 :			if(MYTHREAD == 0)
732 :			print_usage(argv[0]);
733 :			exit(-1);
734 :			}
735 :			else{
736 :			time_limit_set = 1;
737 :			}
738 :			}
739 :			}
740 :	dalvarez	1	else{
741 :			if(i == argc-1 && argv[i][0] != '-' ){
742 :			alternative_output_file = 1;
743 :			output_file = argv[i];
744 :			}
745 :			else{
746 :			if(MYTHREAD == 0){
747 :			printf("Unrecognized option ignored: %s\n",argv[i]);
748 :			}
749 :			}
750 :			}
751 :			}
752 :
753 :			/*
754 :			Optional files checking and parsing
755 :			*/
756 :			set_sizes(alternative_sizes,sizes_file);
757 :			set_bms(alternative_bm_list,bm_file);
758 :
759 :			/*
760 :			Optional output file
761 :			*/
762 :			if(alternative_output_file){
763 :			errno = 0;
764 :			unit = fopen(output_file,"w");
765 :			if(errno != 0){
766 :			if(MYTHREAD == 0){
767 :			fprintf(stderr,"*** Error creating or truncating file %s: ",output_file);
768 :			perror(NULL);
769 :			}
770 :			upc_barrier;
771 :			exit(-1);
772 :			}
773 :			}
774 :			else{
775 :			unit = stdout;
776 :			}
777 :			UOMS_init();
778 :			}

---

root@forge.cesga.es	ViewVC Help
Powered by ViewVC 1.0.0