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

Parent Directory | Revision Log

---

Revision 14 - (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 <sched.h>
51 :			#include <stdio.h>
52 :			#include <stdlib.h>
53 :			#include <time.h>
54 :			#include <sys/utsname.h>
55 :			#include <sys/time.h>
56 :			#include <values.h>
57 :			#include <stdio.h>
58 :			#include <unistd.h>
59 :			#include <math.h>
60 :			#include <string.h>
61 :
62 :			/* UPC */
63 :			#include <upc.h>
64 :			#include <upc_collective.h>
65 :
66 :			/* Timers */
67 :			#include "timers.h"
68 :
69 :			#include "defines.h"
70 :			#include "headers.h"
71 :
72 :			FILE* unit;
73 :
74 :			/*
75 :			Distributed array used in various benchmarks
76 :			*/
77 :			shared char *distArr;
78 :
79 :			/*
80 :			Broadcast array
81 :			*/
82 :			shared [] char *broadcastArr;
83 :
84 :			/*
85 :			Scatter array
86 :			*/
87 :			shared [] char *scatterArr;
88 :
89 :			/*
90 :			Gather array
91 :			*/
92 :			shared [] char *gatherArr;
93 :
94 :			/*
95 :			Gatherall array
96 :			*/
97 :			shared char *gatherallArr;
98 :
99 :			/*
100 :			Exchange array
101 :			*/
102 :			shared char *exchangeArr;
103 :
104 :			/*
105 :			Permute array
106 :			*/
107 :			shared char *permuteArr;
108 :
109 :			/*
110 :			Reduce array (will store only 1 element)
111 :			*/
112 :			shared [] char *reduceArr;
113 :
114 :			/*
115 :			Prefix reduce array
116 :			*/
117 :			shared char *prefixReduceArr;
118 :
119 :			/*
120 :			Pointer for memory allocation and freeing test
121 :			*/
122 :			shared char *mem_alloc_tests_pointer;
123 :
124 :			/*
125 :			Arrays for p2p benchmarking
126 :			*/
127 :			shared char *p2pDistArr;
128 :			shared char *p2pDistArr2;
129 :			char *p2pLocalArr;
130 :			char *p2pLocalArr2;
131 :
132 :			shared double b;// for reduction result
133 :			shared int perm[THREADS]; //for permutation
134 :	dalvarez	7	shared long threads_times[THREADS]; //for timing
135 :	dalvarez	1
136 :			long *sizes;
137 :			int num_sizes = 0;
138 :
139 :			int *bm_list;
140 :			int num_bms = 0;
141 :			char * valid_bms[NUM_BMS];
142 :
143 :			int cache_invalidation = 0;
144 :
145 :			upc_op_t reduce_op = UPC_ADD;
146 :			char * char_reduce_op = "UPC_ADD";
147 :
148 :			int warmup;
149 :
150 :			upc_flag_t sync_mode = UPC_IN_ALLSYNC | UPC_OUT_ALLSYNC;
151 :			char * char_sync_mode = "UPC_IN_ALLSYNC|UPC_OUT_ALLSYNC";
152 :
153 :	dalvarez	14	int global_aux_var = 0;
154 :
155 :	dalvarez	1	int main(int argc, char **argv)
156 :			/*
157 :
158 :			Input variables:
159 :
160 :			-argc (type int)
161 :			Number of command line arguments
162 :
163 :			-argv (type char **)
164 :			List of command line arguments
165 :
166 :			Return value (type int)
167 :			0 always
168 :
169 :			*/
170 :			{
171 :
172 :			init(argc, argv);
173 :
174 :			if (!MYTHREAD)
175 :			UOMS_general_info();
176 :
177 :			for(int i = 0; i < num_bms; i++){
178 :			if(p2poperation(bm_list[i]) == 0){
179 :			bench(bm_list[i]);
180 :			}
181 :			else{
182 :			if (THREADS == 2){
183 :			affinity_bench(bm_list[i]);
184 :			}
185 :			else{
186 :			if(MYTHREAD == 0){
187 :			fprintf(unit,"\n#---------------------------------------------------\n");
188 :			fprintf(unit,"# Skipping benchmark %s. To run it use only 2 threads.\n",valid_bms[bm_list[i]]);
189 :			fprintf(unit,"#---------------------------------------------------\n\n");
190 :			}
191 :			}
192 :			}
193 :			}
194 :
195 :			if(unit != stdout && unit != stderr){
196 :			fclose(unit);
197 :			}
198 :
199 :			return 0;
200 :			}
201 :
202 :
203 :
204 :			int p2poperation(int operation_code) {
205 :			switch (operation_code) {
206 :			case LMEMCPY:
207 :			case MEMCPY:
208 :			case LMEMGET:
209 :			case MEMGET:
210 :			case LMEMPUT:
211 :			case MEMPUT:
212 :			#ifdef ASYNC_MEM_TEST
213 :			case ALMEMCPY:
214 :			case AMEMCPY:
215 :			case ALMEMGET:
216 :			case AMEMGET:
217 :			case ALMEMPUT:
218 :			case AMEMPUT:
219 :			#endif
220 :	dalvarez	7	#ifdef ASYNCI_MEM_TEST
221 :			case AILMEMCPY:
222 :			case AIMEMCPY:
223 :			case AILMEMGET:
224 :			case AIMEMGET:
225 :			case AILMEMPUT:
226 :			case AIMEMPUT:
227 :			#endif
228 :	dalvarez	1	case SMEMCPY:
229 :			case MEMMOVE:
230 :			return 1;
231 :			default:
232 :			break;
233 :			}
234 :			return 0;
235 :			}
236 :
237 :			/*
238 :			Generic bench function
239 :			*/
240 :			void bench(int operation_code) {
241 :
242 :			long int cursize;
243 :			long int niterations, iter;
244 :			uint64_t start, end;
245 :			uint64_t minTime, totalTime, maxTime, prevMinTime;
246 :
247 :			if (!MYTHREAD)
248 :			UOMS_function_info(operation_code,THREADS,operation_header(operation_code));
249 :
250 :			int global_iter;
251 :			int initial_iter = (warmup)?0:1;
252 :
253 :			int mem_is_ok;
254 :
255 :			for(global_iter = initial_iter; global_iter <2; global_iter++) {
256 :
257 :			prevMinTime = 0;
258 :
259 :			/*
260 :			Benchmarking coll with cursize-size and niterations-iterations
261 :			*/
262 :			for(int cursize_index=0;cursize_index<num_sizes;cursize_index++){
263 :
264 :			cursize = sizes[cursize_index];
265 :
266 :			/*
267 :			Skip test that do not achieve the minimum size
268 :			*/
269 :			if(cursize <= 0){
270 :			continue;
271 :			}
272 :			else if(operation_code == REDUCE_C || operation_code == PREFIX_REDUCE_C){
273 :			if(cursize<sizeof(char)){
274 :			continue;
275 :			}
276 :			}
277 :			else if(operation_code == REDUCE_UC || operation_code == PREFIX_REDUCE_UC){
278 :			if(cursize<sizeof(unsigned char)){
279 :			continue;
280 :			}
281 :			}
282 :			else if(operation_code == REDUCE_S || operation_code == PREFIX_REDUCE_S){
283 :			if(cursize<sizeof(short)){
284 :			continue;
285 :			}
286 :			}
287 :			else if(operation_code == REDUCE_US || operation_code == PREFIX_REDUCE_US){
288 :			if(cursize<sizeof(unsigned short)){
289 :			continue;
290 :			}
291 :			}
292 :			else if(operation_code == REDUCE_I || operation_code == PREFIX_REDUCE_I){
293 :			if(cursize<sizeof(int)){
294 :			continue;
295 :			}
296 :			}
297 :			else if(operation_code == REDUCE_UI || operation_code == PREFIX_REDUCE_UI){
298 :			if(cursize<sizeof(unsigned int)){
299 :			continue;
300 :			}
301 :			}
302 :			else if(operation_code == REDUCE_L || operation_code == PREFIX_REDUCE_L){
303 :			if(cursize<sizeof(long)){
304 :			continue;
305 :			}
306 :			}
307 :			else if(operation_code == REDUCE_UL || operation_code == PREFIX_REDUCE_UL){
308 :			if(cursize<sizeof(unsigned long)){
309 :			continue;
310 :			}
311 :			}
312 :			else if(operation_code == REDUCE_F || operation_code == PREFIX_REDUCE_F){
313 :			if(cursize<sizeof(float)){
314 :			continue;
315 :			}
316 :			}
317 :			else if(operation_code == REDUCE_D || operation_code == PREFIX_REDUCE_D){
318 :			if(cursize<sizeof(double)){
319 :			continue;
320 :			}
321 :			}
322 :			else if(operation_code == REDUCE_LD || operation_code == PREFIX_REDUCE_LD){
323 :			if(cursize<sizeof(long double)){
324 :			continue;
325 :			}
326 :			}
327 :
328 :			long int nbuckets;
329 :			niterations = niters(cursize);
330 :
331 :			if(cache_invalidation == 1){
332 :			nbuckets=niterations;
333 :			}
334 :			else{
335 :			nbuckets=1;
336 :			}
337 :
338 :	dalvarez	14	if(allocate_arrays(operation_code,cursize,nbuckets) == -1) // Unsuccessful allocation
339 :	dalvarez	1	continue;
340 :
341 :			upc_barrier;
342 :
343 :			minTime=MAXLONG;
344 :			maxTime=0L;
345 :			totalTime=0L;
346 :
347 :			uint64_t tmax;
348 :
349 :			for(iter=0;iter<niterations;iter++){
350 :
351 :			/*
352 :			For this benchmark the array should be allocated per iteration
353 :			*/
354 :			if(operation_code == FREE){
355 :			mem_alloc_tests_pointer = upc_all_alloc(THREADS,cursize);
356 :			UPCMEM_OK(mem_alloc_tests_pointer);
357 :			if(mem_is_ok == -1)
358 :			continue;
359 :			}
360 :
361 :			upc_barrier;
362 :
363 :			start = getTicks();
364 :			function(operation_code,cursize,(iter%nbuckets)*cursize);
365 :			upc_barrier;
366 :			end = getTicks() - start;
367 :
368 :	dalvarez	14	/*
369 :			For this benchmark the array should be freed per iteration
370 :			*/
371 :	dalvarez	1	if(operation_code == ALLALLOC){
372 :			UPCMEM_OK(mem_alloc_tests_pointer);
373 :			if(mem_is_ok == -1)
374 :			continue;
375 :			upc_barrier;
376 :			if(MYTHREAD == 0)
377 :			upc_free(mem_alloc_tests_pointer);
378 :			}
379 :
380 :	dalvarez	7	threads_times[MYTHREAD]=end;
381 :	dalvarez	1	upc_barrier;
382 :			if (MYTHREAD == 0) {
383 :			int i;
384 :			tmax = 0L;
385 :			for(i=0;i<THREADS;i++) {
386 :	dalvarez	7	if (threads_times[i]>tmax)
387 :			tmax=threads_times[i];
388 :	dalvarez	1	}
389 :			}
390 :			end=tmax;
391 :
392 :			totalTime+=end;
393 :
394 :			//in order to avoid irregular latencies for short messages
395 :			if (end<minTime)
396 :			minTime = ((end<prevMinTime)&&(cursize<32*1024))?prevMinTime:end;
397 :			if (end>maxTime)
398 :			maxTime = end;
399 :			}
400 :
401 :			upc_barrier;
402 :
403 :			free_arrays(operation_code);
404 :
405 :			if(global_iter)
406 :			print_performance_data(operation_code,cursize,niterations,minTime,maxTime,totalTime);
407 :			prevMinTime = minTime;
408 :
409 :			upc_barrier;
410 :
411 :			if(operation_code == BARRIER){
412 :			break;
413 :			}
414 :
415 :			}
416 :
417 :			}//fi global_iter
418 :
419 :			return;
420 :
421 :			}
422 :
423 :
424 :
425 :			/*
426 :			Call the corresponding function
427 :			*/
428 :			void function(int operation_code, long int cursize,long int offset){
429 :
430 :	dalvarez	14	int aux_var = 0;
431 :
432 :	dalvarez	1	switch (operation_code) {
433 :	dalvarez	14	case FORALL_R:
434 :			upc_forall(int i = offset; i < cursize*THREADS+offset; i++; &distArr[i]){
435 :			aux_var+=distArr[i];
436 :			}
437 :			/*
438 :			Some compilers with aggressive optimizations may drop the whole loop if they detect that
439 :			aux_var is not going to be used. Writing its value to an external variable may prevent this.
440 :			*/
441 :			global_aux_var = aux_var;
442 :			break;
443 :			case FORALL_W:
444 :			upc_forall(int i = offset; i < cursize*THREADS+offset; i++; &distArr[i]){
445 :			distArr[i] = i;
446 :			}
447 :			break;
448 :			case FORALL_RW:
449 :			upc_forall(int i = offset; i < cursize*THREADS+offset; i++; &distArr[i]){
450 :			distArr[i] += i;
451 :			}
452 :			break;
453 :			case FOR_R:
454 :			if(MYTHREAD == 0){
455 :			for(int i = offset; i < cursize*THREADS+offset; i++){
456 :			aux_var+=distArr[i];
457 :			}
458 :			}
459 :			/*
460 :			Some compilers with aggressive optimizations may drop the whole loop if they detect that
461 :			aux_var is not going to be used. Writing its value to an external variable may prevent this.
462 :			*/
463 :			global_aux_var = aux_var;
464 :			break;
465 :			case FOR_W:
466 :			if(MYTHREAD == 0){
467 :			for(int i = offset; i < cursize*THREADS+offset; i++){
468 :			distArr[i] = i;
469 :			}
470 :			}
471 :			break;
472 :			case FOR_RW:
473 :			if(MYTHREAD == 0){
474 :			for(int i = offset; i < cursize*THREADS+offset; i++){
475 :			distArr[i] += i;
476 :			}
477 :			}
478 :			break;
479 :	dalvarez	1	case BROADCAST:
480 :	dalvarez	14	upc_all_broadcast(&(distArr[THREADS*offset]),&(broadcastArr[offset]), cursize, sync_mode);
481 :			break;
482 :	dalvarez	1	case SCATTER:
483 :	dalvarez	14	upc_all_scatter(&(distArr[THREADS*offset]),&(scatterArr[THREADS*offset]), cursize, sync_mode);
484 :			break;
485 :	dalvarez	1	case GATHER:
486 :	dalvarez	14	upc_all_gather( &(gatherArr[THREADS*offset]),&(distArr[THREADS*offset]), cursize, sync_mode);
487 :			break;
488 :	dalvarez	1	case GATHERALL:
489 :	dalvarez	14	upc_all_gather_all( &(gatherallArr[THREADS*THREADS*offset]),&(distArr[THREADS*offset]), cursize, sync_mode);
490 :			break;
491 :	dalvarez	1	case EXCHANGE:
492 :	dalvarez	14	upc_all_exchange(&(exchangeArr[THREADS*THREADS*offset]), &(distArr[THREADS*THREADS*offset]), cursize, sync_mode );
493 :			break;
494 :	dalvarez	1	case PERMUTE:
495 :	dalvarez	14	upc_all_permute(&(permuteArr[THREADS*offset]), &(distArr[THREADS*offset]), perm, cursize, sync_mode );
496 :			break;
497 :	dalvarez	1	case REDUCE_C:
498 :	dalvarez	14	upc_all_reduceC((shared char *)reduceArr, (shared char*)&(distArr[THREADS*offset]),
499 :			reduce_op, (cursize/sizeof(char))*THREADS, cursize/sizeof(char), NULL, sync_mode );
500 :			break;
501 :	dalvarez	1	case PREFIX_REDUCE_C:
502 :	dalvarez	14	upc_all_prefix_reduceC((shared char *)&(distArr[THREADS*offset]), (shared char *)&(prefixReduceArr[THREADS*offset]),
503 :			reduce_op, (cursize/sizeof(char))*THREADS, cursize/sizeof(char), NULL, sync_mode );
504 :			break;
505 :	dalvarez	1	case REDUCE_UC:
506 :	dalvarez	14	upc_all_reduceUC((shared unsigned char *)reduceArr, (shared unsigned char *)&(distArr[THREADS*offset]),
507 :			reduce_op, (cursize/sizeof(unsigned char))*THREADS, cursize/sizeof(unsigned char), NULL, sync_mode );
508 :			break;
509 :	dalvarez	1	case PREFIX_REDUCE_UC:
510 :	dalvarez	14	upc_all_prefix_reduceUC((shared unsigned char *)&(distArr[THREADS*offset]), (shared unsigned char *)&(prefixReduceArr[THREADS*offset]),
511 :			reduce_op, (cursize/sizeof(unsigned char))*THREADS, cursize/sizeof(unsigned char), NULL, sync_mode );
512 :			break;
513 :	dalvarez	1	case REDUCE_S:
514 :	dalvarez	14	upc_all_reduceS((shared short *)reduceArr, (shared short *)&(distArr[THREADS*offset]),
515 :			reduce_op, (cursize/sizeof(short))*THREADS, cursize/sizeof(short), NULL, sync_mode );
516 :			break;
517 :	dalvarez	1	case PREFIX_REDUCE_S:
518 :	dalvarez	14	upc_all_prefix_reduceS((shared short *)&(distArr[THREADS*offset]), (shared short *)&(prefixReduceArr[THREADS*offset]),
519 :			reduce_op, (cursize/sizeof(short))*THREADS, cursize/sizeof(short), NULL, sync_mode );
520 :			break;
521 :	dalvarez	1	case REDUCE_US:
522 :	dalvarez	14	upc_all_reduceUS((shared unsigned short *)reduceArr, (shared unsigned short *)&(distArr[THREADS*offset]),
523 :			reduce_op, (cursize/sizeof(unsigned short))*THREADS, cursize/sizeof(unsigned short), NULL, sync_mode );
524 :			break;
525 :	dalvarez	1	case PREFIX_REDUCE_US:
526 :	dalvarez	14	upc_all_prefix_reduceUS((shared unsigned short *)&(distArr[THREADS*offset]), (shared unsigned short *)&(prefixReduceArr[THREADS*offset]),
527 :			reduce_op, (cursize/sizeof(unsigned short))*THREADS, cursize/sizeof(unsigned short), NULL, sync_mode );
528 :			break;
529 :	dalvarez	1	case REDUCE_I:
530 :	dalvarez	14	upc_all_reduceI((shared int *)reduceArr, (shared int *)&(distArr[THREADS*offset]),
531 :			reduce_op, (cursize/sizeof(int))*THREADS, cursize/sizeof(int), NULL, sync_mode );
532 :			break;
533 :	dalvarez	1	case PREFIX_REDUCE_I:
534 :	dalvarez	14	upc_all_prefix_reduceI((shared int *)&(distArr[THREADS*offset]), (shared int *)&(prefixReduceArr[THREADS*offset]),
535 :			reduce_op, (cursize/sizeof(int))*THREADS, cursize/sizeof(int), NULL, sync_mode );
536 :			break;
537 :	dalvarez	1	case REDUCE_UI:
538 :	dalvarez	14	upc_all_reduceUI((shared unsigned int *)reduceArr, (shared unsigned int *)&(distArr[THREADS*offset]),
539 :			reduce_op, (cursize/sizeof(unsigned int))*THREADS, cursize/sizeof(unsigned int), NULL, sync_mode );
540 :			break;
541 :	dalvarez	1	case PREFIX_REDUCE_UI:
542 :	dalvarez	14	upc_all_prefix_reduceUI((shared unsigned int *)&(distArr[THREADS*offset]), (shared unsigned int *)&(prefixReduceArr[THREADS*offset]),
543 :			reduce_op, (cursize/sizeof(unsigned int))*THREADS, cursize/sizeof(unsigned int), NULL, sync_mode );
544 :			break;
545 :	dalvarez	1	case REDUCE_L:
546 :	dalvarez	14	upc_all_reduceL((shared long *)reduceArr, (shared long *)&(distArr[THREADS*offset]),
547 :			reduce_op, (cursize/sizeof(long))*THREADS, cursize/sizeof(long), NULL, sync_mode );
548 :			break;
549 :	dalvarez	1	case PREFIX_REDUCE_L:
550 :	dalvarez	14	upc_all_prefix_reduceL((shared long *)&(distArr[THREADS*offset]), (shared long *)&(prefixReduceArr[THREADS*offset]),
551 :			reduce_op, (cursize/sizeof(long))*THREADS, cursize/sizeof(long), NULL, sync_mode );
552 :			break;
553 :	dalvarez	1	case REDUCE_UL:
554 :	dalvarez	14	upc_all_reduceUL((shared unsigned long *)reduceArr, (shared unsigned long *)&(distArr[THREADS*offset]),
555 :			reduce_op, (cursize/sizeof(unsigned long))*THREADS, cursize/sizeof(unsigned long), NULL, sync_mode );
556 :			break;
557 :	dalvarez	1	case PREFIX_REDUCE_UL:
558 :	dalvarez	14	upc_all_prefix_reduceUL((shared unsigned long *)&(distArr[THREADS*offset]), (shared unsigned long *)&(prefixReduceArr[THREADS*offset]),
559 :			reduce_op, (cursize/sizeof(unsigned long))*THREADS, cursize/sizeof(unsigned long), NULL, sync_mode );
560 :			break;
561 :	dalvarez	1	case REDUCE_F:
562 :	dalvarez	14	upc_all_reduceF((shared float *)reduceArr, (shared float *)&(distArr[THREADS*offset]),
563 :			reduce_op, (cursize/sizeof(float))*THREADS, cursize/sizeof(float), NULL, sync_mode );
564 :			break;
565 :	dalvarez	1	case PREFIX_REDUCE_F:
566 :	dalvarez	14	upc_all_prefix_reduceF((shared float *)&(distArr[THREADS*offset]), (shared float *)&(prefixReduceArr[THREADS*offset]),
567 :			reduce_op, (cursize/sizeof(float))*THREADS, cursize/sizeof(float), NULL, sync_mode );
568 :			break;
569 :	dalvarez	1	case REDUCE_D:
570 :	dalvarez	14	upc_all_reduceD((shared double *)reduceArr, (shared double *)&(distArr[THREADS*offset]),
571 :			reduce_op, (cursize/sizeof(double))*THREADS, cursize/sizeof(double), NULL, sync_mode );
572 :			break;
573 :	dalvarez	1	case PREFIX_REDUCE_D:
574 :	dalvarez	14	upc_all_prefix_reduceD((shared double *)&(distArr[THREADS*offset]), (shared double *)&(prefixReduceArr[THREADS*offset]),
575 :			reduce_op, (cursize/sizeof(double))*THREADS, cursize/sizeof(double), NULL, sync_mode );
576 :			break;
577 :	dalvarez	1	case REDUCE_LD:
578 :	dalvarez	14	upc_all_reduceLD((shared long double *)reduceArr, (shared long double *)&(distArr[THREADS*offset]),
579 :			reduce_op, (cursize/sizeof(long double))*THREADS, cursize/sizeof(long double), NULL, sync_mode );
580 :			break;
581 :	dalvarez	1	case PREFIX_REDUCE_LD:
582 :	dalvarez	14	upc_all_prefix_reduceLD((shared long double *)&(distArr[THREADS*offset]),(shared long double *)&(prefixReduceArr[THREADS*offset]),
583 :			reduce_op, (cursize/sizeof(long double))*THREADS, cursize/sizeof(long double), NULL, sync_mode );
584 :			break;
585 :	dalvarez	1	case BARRIER:
586 :	dalvarez	14	upc_barrier;
587 :			break;
588 :	dalvarez	1	case MEMGET:
589 :	dalvarez	14	if (!MYTHREAD)
590 :			upc_memget((p2pLocalArr+offset),&(p2pDistArr[1+THREADS*offset]),cursize);
591 :			break;
592 :	dalvarez	1	case LMEMGET:
593 :	dalvarez	14	if (!MYTHREAD)
594 :			upc_memget((p2pLocalArr+offset),&(p2pDistArr[THREADS*offset]),cursize);
595 :			break;
596 :			#ifdef ASYNC_MEM_TEST
597 :	dalvarez	1	case AMEMGET:
598 :	dalvarez	14	if (!MYTHREAD){
599 :			upc_handle_t handler = upc_memget_async((p2pLocalArr+offset),&(p2pDistArr[1+THREADS*offset]),cursize);
600 :			upc_waitsync(handler);
601 :			}
602 :			break;
603 :	dalvarez	7	case ALMEMGET:
604 :	dalvarez	14	if (!MYTHREAD){
605 :			upc_handle_t handler = upc_memget_async((p2pLocalArr+offset),&(p2pDistArr[THREADS*offset]),cursize);
606 :			upc_waitsync(handler);
607 :			}
608 :			break;
609 :			#endif
610 :			#ifdef ASYNCI_MEM_TEST
611 :	dalvarez	7	case AIMEMGET:
612 :	dalvarez	14	if (!MYTHREAD){
613 :			upc_memget_asynci((p2pLocalArr+offset),&(p2pDistArr[1+THREADS*offset]),cursize);
614 :			upc_waitsynci();
615 :			}
616 :			break;
617 :	dalvarez	7	case AILMEMGET:
618 :	dalvarez	14	if (!MYTHREAD){
619 :			upc_memget_asynci((p2pLocalArr+offset),&(p2pDistArr[THREADS*offset]),cursize);
620 :			upc_waitsynci();
621 :			}
622 :			break;
623 :			#endif
624 :	dalvarez	1	case MEMPUT:
625 :	dalvarez	14	if (!MYTHREAD)
626 :			upc_memput(&(p2pDistArr[1+THREADS*offset]),p2pLocalArr+offset,cursize);
627 :			break;
628 :	dalvarez	1	case LMEMPUT:
629 :	dalvarez	14	if (!MYTHREAD)
630 :			upc_memput(&(p2pDistArr[THREADS*offset]),p2pLocalArr+offset,cursize);
631 :			break;
632 :			#ifdef ASYNC_MEM_TEST
633 :	dalvarez	1	case AMEMPUT:
634 :	dalvarez	14	if (!MYTHREAD){
635 :			upc_handle_t handler = upc_memput_async(&(p2pDistArr[1+THREADS*offset]),p2pLocalArr+offset,cursize);
636 :			upc_waitsync(handler);
637 :			}
638 :			break;
639 :	dalvarez	7	case ALMEMPUT:
640 :	dalvarez	14	if (!MYTHREAD){
641 :			upc_handle_t handler = upc_memput_async(&(p2pDistArr[THREADS*offset]),p2pLocalArr+offset,cursize);
642 :			upc_waitsync(handler);
643 :			}
644 :			break;
645 :			#endif
646 :			#ifdef ASYNCI_MEM_TEST
647 :	dalvarez	7	case AIMEMPUT:
648 :	dalvarez	14	if (!MYTHREAD){
649 :			upc_memput_asynci(&(p2pDistArr[1+THREADS*offset]),p2pLocalArr+offset,cursize);
650 :			upc_waitsynci();
651 :			}
652 :			break;
653 :	dalvarez	7	case AILMEMPUT:
654 :	dalvarez	14	if (!MYTHREAD){
655 :			upc_memput_asynci(&(p2pDistArr[THREADS*offset]),p2pLocalArr+offset,cursize);
656 :			upc_waitsynci();
657 :			}
658 :			break;
659 :			#endif
660 :	dalvarez	1	case MEMCPY:
661 :	dalvarez	14	if (!MYTHREAD)
662 :			upc_memcpy(&(p2pDistArr[1+THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
663 :			break;
664 :	dalvarez	1	case LMEMCPY:
665 :	dalvarez	14	if (!MYTHREAD)
666 :			upc_memcpy(&(p2pDistArr[THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
667 :			break;
668 :			#ifdef ASYNC_MEM_TEST
669 :	dalvarez	1	case AMEMCPY:
670 :	dalvarez	14	if (!MYTHREAD){
671 :			upc_handle_t handler = upc_memcpy_async(&(p2pDistArr[1+THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
672 :			upc_waitsync(handler);
673 :			}
674 :			break;
675 :	dalvarez	7	case ALMEMCPY:
676 :	dalvarez	14	if (!MYTHREAD){
677 :			upc_handle_t handler = upc_memcpy_async(&(p2pDistArr[THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
678 :			upc_waitsync(handler);
679 :			}
680 :			break;
681 :			#endif
682 :			#ifdef ASYNCI_MEM_TEST
683 :	dalvarez	7	case AIMEMCPY:
684 :	dalvarez	14	if (!MYTHREAD){
685 :			upc_memcpy_asynci(&(p2pDistArr[1+THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
686 :			upc_waitsynci();
687 :			}
688 :			break;
689 :	dalvarez	7	case AILMEMCPY:
690 :	dalvarez	14	if (!MYTHREAD){
691 :			upc_memcpy_asynci(&(p2pDistArr[THREADS*offset]),&(p2pDistArr2[THREADS*offset]),cursize);
692 :			upc_waitsynci();
693 :			}
694 :			break;
695 :			#endif
696 :	dalvarez	1	case SMEMCPY:
697 :	dalvarez	14	if (!MYTHREAD)
698 :			memcpy(p2pLocalArr2+offset,p2pLocalArr+offset,cursize);
699 :			break;
700 :	dalvarez	1	case MEMMOVE:
701 :	dalvarez	14	if (!MYTHREAD)
702 :			memmove(p2pLocalArr2+offset,p2pLocalArr+offset,cursize);
703 :			break;
704 :	dalvarez	1	case ALLALLOC:
705 :	dalvarez	14	mem_alloc_tests_pointer = upc_all_alloc(THREADS,cursize);
706 :			break;
707 :	dalvarez	1	case FREE:
708 :	dalvarez	14	if(!MYTHREAD)
709 :			upc_free(mem_alloc_tests_pointer);
710 :			break;
711 :	dalvarez	1
712 :			default:
713 :	dalvarez	14	break;
714 :	dalvarez	1	}
715 :			return;
716 :			}
717 :

---

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