Annotation of /trunk/uoms/src/mem_manager.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 <upc.h>
51 :			#include <stdlib.h>
52 :			#include <stdio.h>
53 :			#include "defines.h"
54 :			#include "headers.h"
55 :
56 :			/*
57 :			Distributed array used in various benchmarks
58 :			*/
59 :			extern shared char *distArr;
60 :
61 :			/*
62 :			Broadcast array
63 :			*/
64 :			extern shared [] char *broadcastArr;
65 :
66 :			/*
67 :			Scatter array
68 :			*/
69 :			extern shared [] char *scatterArr;
70 :
71 :			/*
72 :			Gather array
73 :			*/
74 :			extern shared [] char *gatherArr;
75 :
76 :			/*
77 :			Gatherall array
78 :			*/
79 :			extern shared char *gatherallArr;
80 :
81 :			/*
82 :			Exchange array
83 :			*/
84 :			extern shared char *exchangeArr;
85 :
86 :			/*
87 :			Permute array
88 :			*/
89 :			extern shared char *permuteArr;
90 :
91 :			/*
92 :			Reduce array (will store only 1 element)
93 :			*/
94 :			extern shared [] char *reduceArr;
95 :
96 :			/*
97 :			Prefix reduce array
98 :			*/
99 :			extern shared char *prefixReduceArr;
100 :
101 :			/*
102 :			Pointer for memory allocation and freeing test
103 :			*/
104 :			extern shared char *mem_alloc_tests_pointer;
105 :
106 :			/*
107 :			Arrays for p2p benchmarking
108 :			*/
109 :			extern shared char *p2pDistArr;
110 :			extern shared char *p2pDistArr2;
111 :			extern char *p2pLocalArr;
112 :			extern char *p2pLocalArr2;
113 :
114 :			int allocate_arrays(int operation_code, long int cursize, long int nbuckets){
115 :
116 :			size_t nbytes = cursize*nbuckets;
117 :			int mem_is_ok;
118 :
119 :			/*
120 :			Setup p2p arrays
121 :			*/
122 :			if (p2poperation(operation_code)) {
123 :			p2pLocalArr = (char *) malloc(nbytes);
124 :			MEM_OK(p2pLocalArr);
125 :			if(mem_is_ok == -1) return -1;
126 :			if(operation_code == SMEMCPY || operation_code == MEMMOVE){
127 :			p2pLocalArr2 = (char *) malloc(nbytes);
128 :			MEM_OK(p2pLocalArr2);
129 :			if(mem_is_ok == -1) return -1;
130 :			}
131 :			else{
132 :			p2pDistArr = upc_all_alloc(THREADS,nbytes);
133 :			UPCMEM_OK(p2pDistArr);
134 :			if(mem_is_ok == -1) return -1;
135 :	dalvarez	7	#if defined (ASYNC_MEM_TEST) || defined (ASYNCI_MEM_TEST)
136 :	dalvarez	1	if(operation_code == MEMCPY || operation_code == LMEMCPY ||
137 :	dalvarez	7	operation_code == AMEMCPY || operation_code == ALMEMCPY ||
138 :			operation_code == AIMEMCPY || operation_code == AILMEMCPY){
139 :	dalvarez	1	#else
140 :			if(operation_code == MEMCPY || operation_code == LMEMCPY){
141 :			#endif
142 :			p2pDistArr2 = upc_all_alloc(THREADS,nbytes);
143 :			UPCMEM_OK(p2pDistArr);
144 :			if(mem_is_ok == -1) return -1;
145 :			}
146 :			}
147 :			}
148 :			/*
149 :			Setup collective arrays
150 :			*/
151 :			else{
152 :	dalvarez	14
153 :	dalvarez	1	size_t dist_blk_size = 0;
154 :			size_t num_dist_blk = 0;
155 :	dalvarez	14	if(operation_code == FORALL_R){
156 :	dalvarez	1	dist_blk_size = cursize;
157 :			num_dist_blk = THREADS*nbuckets;
158 :	dalvarez	14	}
159 :			else if(operation_code == FORALL_W){
160 :			dist_blk_size = cursize;
161 :			num_dist_blk = THREADS*nbuckets;
162 :			}
163 :			else if(operation_code == FORALL_RW){
164 :			dist_blk_size = cursize;
165 :			num_dist_blk = THREADS*nbuckets;
166 :			}
167 :			else if(operation_code == FOR_R){
168 :			dist_blk_size = cursize;
169 :			num_dist_blk = THREADS*nbuckets;
170 :			}
171 :			else if(operation_code == FOR_W){
172 :			dist_blk_size = cursize;
173 :			num_dist_blk = THREADS*nbuckets;
174 :			}
175 :			else if(operation_code == FOR_RW){
176 :			dist_blk_size = cursize;
177 :			num_dist_blk = THREADS*nbuckets;
178 :			}
179 :			else if(operation_code == BROADCAST){
180 :			dist_blk_size = cursize;
181 :			num_dist_blk = THREADS*nbuckets;
182 :	dalvarez	1	broadcastArr = upc_all_alloc(1,nbytes);
183 :			UPCMEM_OK(broadcastArr);
184 :			if(mem_is_ok == -1) return -1;
185 :			}
186 :			else if(operation_code == SCATTER){
187 :			dist_blk_size = cursize;
188 :			num_dist_blk = THREADS*nbuckets;
189 :			scatterArr = upc_all_alloc(1,nbytes*THREADS);
190 :			UPCMEM_OK(scatterArr);
191 :			if(mem_is_ok == -1) return -1;
192 :			}
193 :			else if(operation_code == GATHER){
194 :			dist_blk_size = cursize;
195 :			num_dist_blk = THREADS*nbuckets;
196 :			gatherArr = upc_all_alloc(1,nbytes*THREADS);
197 :			UPCMEM_OK(gatherArr);
198 :			if(mem_is_ok == -1) return -1;
199 :			}
200 :			else if(operation_code == GATHERALL){
201 :			dist_blk_size = cursize;
202 :			num_dist_blk = THREADS*nbuckets;
203 :			gatherallArr = upc_all_alloc(num_dist_blk,cursize*THREADS);
204 :			UPCMEM_OK(gatherallArr);
205 :			if(mem_is_ok == -1) return -1;
206 :			}
207 :			else if(operation_code == EXCHANGE){
208 :			dist_blk_size = cursize*THREADS;
209 :			num_dist_blk = THREADS*nbuckets;
210 :			exchangeArr = upc_all_alloc(num_dist_blk,dist_blk_size);
211 :			UPCMEM_OK(exchangeArr);
212 :			if(mem_is_ok == -1) return -1;
213 :			}
214 :			else if(operation_code == PERMUTE){
215 :			dist_blk_size = cursize;
216 :			num_dist_blk = THREADS*nbuckets;
217 :			permuteArr = upc_all_alloc(num_dist_blk,dist_blk_size);
218 :			UPCMEM_OK(permuteArr);
219 :			if(mem_is_ok == -1) return -1;
220 :			}
221 :			else if(operation_code == REDUCE_C){
222 :			dist_blk_size = cursize;
223 :			num_dist_blk = THREADS*nbuckets;
224 :			reduceArr = upc_all_alloc(1,sizeof(char));
225 :			UPCMEM_OK(reduceArr);
226 :			if(mem_is_ok == -1) return -1;
227 :			}
228 :			else if(operation_code == PREFIX_REDUCE_C){
229 :			dist_blk_size = cursize;
230 :			num_dist_blk = THREADS*nbuckets;
231 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
232 :			UPCMEM_OK(prefixReduceArr);
233 :			if(mem_is_ok == -1) return -1;
234 :			}
235 :			else if(operation_code == REDUCE_UC){
236 :			dist_blk_size = cursize;
237 :			num_dist_blk = THREADS*nbuckets;
238 :			reduceArr = upc_all_alloc(1,sizeof(unsigned char));
239 :			UPCMEM_OK(reduceArr);
240 :			if(mem_is_ok == -1) return -1;
241 :			}
242 :			else if(operation_code == PREFIX_REDUCE_UC){
243 :			dist_blk_size = cursize;
244 :			num_dist_blk = THREADS*nbuckets;
245 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
246 :			UPCMEM_OK(prefixReduceArr);
247 :			if(mem_is_ok == -1) return -1;
248 :			}
249 :			else if(operation_code == REDUCE_S){
250 :			dist_blk_size = cursize;
251 :			num_dist_blk = THREADS*nbuckets;
252 :			reduceArr = upc_all_alloc(1,sizeof(short));
253 :			UPCMEM_OK(reduceArr);
254 :			if(mem_is_ok == -1) return -1;
255 :			}
256 :			else if(operation_code == PREFIX_REDUCE_S){
257 :			dist_blk_size = cursize;
258 :			num_dist_blk = THREADS*nbuckets;
259 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
260 :			UPCMEM_OK(prefixReduceArr);
261 :			if(mem_is_ok == -1) return -1;
262 :			}
263 :			else if(operation_code == REDUCE_US){
264 :			dist_blk_size = cursize;
265 :			num_dist_blk = THREADS*nbuckets;
266 :			reduceArr = upc_all_alloc(1,sizeof(unsigned short));
267 :			UPCMEM_OK(reduceArr);
268 :			if(mem_is_ok == -1) return -1;
269 :			}
270 :			else if(operation_code == PREFIX_REDUCE_US){
271 :			dist_blk_size = cursize;
272 :			num_dist_blk = THREADS*nbuckets;
273 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
274 :			UPCMEM_OK(prefixReduceArr);
275 :			if(mem_is_ok == -1) return -1;
276 :			}
277 :			else if(operation_code == REDUCE_I){
278 :			dist_blk_size = cursize;
279 :			num_dist_blk = THREADS*nbuckets;
280 :			reduceArr = upc_all_alloc(1,sizeof(int));
281 :			UPCMEM_OK(reduceArr);
282 :			if(mem_is_ok == -1) return -1;
283 :			}
284 :			else if(operation_code == PREFIX_REDUCE_I){
285 :			dist_blk_size = cursize;
286 :			num_dist_blk = THREADS*nbuckets;
287 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
288 :			UPCMEM_OK(prefixReduceArr);
289 :			if(mem_is_ok == -1) return -1;
290 :			}
291 :			else if(operation_code == REDUCE_UI){
292 :			dist_blk_size = cursize;
293 :			num_dist_blk = THREADS*nbuckets;
294 :			reduceArr = upc_all_alloc(1,sizeof(unsigned int));
295 :			UPCMEM_OK(reduceArr);
296 :			if(mem_is_ok == -1) return -1;
297 :			}
298 :			else if(operation_code == PREFIX_REDUCE_UI){
299 :			dist_blk_size = cursize;
300 :			num_dist_blk = THREADS*nbuckets;
301 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
302 :			UPCMEM_OK(prefixReduceArr);
303 :			if(mem_is_ok == -1) return -1;
304 :			}
305 :			else if(operation_code == REDUCE_L){
306 :			dist_blk_size = cursize;
307 :			num_dist_blk = THREADS*nbuckets;
308 :			reduceArr = upc_all_alloc(1,sizeof(long));
309 :			UPCMEM_OK(reduceArr);
310 :			if(mem_is_ok == -1) return -1;
311 :			}
312 :			else if(operation_code == PREFIX_REDUCE_L){
313 :			dist_blk_size = cursize;
314 :			num_dist_blk = THREADS*nbuckets;
315 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
316 :			UPCMEM_OK(prefixReduceArr);
317 :			if(mem_is_ok == -1) return -1;
318 :			}
319 :			else if(operation_code == REDUCE_UL){
320 :			dist_blk_size = cursize;
321 :			num_dist_blk = THREADS*nbuckets;
322 :			reduceArr = upc_all_alloc(1,sizeof(unsigned long));
323 :			UPCMEM_OK(reduceArr);
324 :			if(mem_is_ok == -1) return -1;
325 :			}
326 :			else if(operation_code == PREFIX_REDUCE_UL){
327 :			dist_blk_size = cursize;
328 :			num_dist_blk = THREADS*nbuckets;
329 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
330 :			UPCMEM_OK(prefixReduceArr);
331 :			if(mem_is_ok == -1) return -1;
332 :			}
333 :			else if(operation_code == REDUCE_F){
334 :			dist_blk_size = cursize;
335 :			num_dist_blk = THREADS*nbuckets;
336 :			reduceArr = upc_all_alloc(1,sizeof(float));
337 :			UPCMEM_OK(reduceArr);
338 :			if(mem_is_ok == -1) return -1;
339 :			}
340 :			else if(operation_code == PREFIX_REDUCE_F){
341 :			dist_blk_size = cursize;
342 :			num_dist_blk = THREADS*nbuckets;
343 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
344 :			UPCMEM_OK(prefixReduceArr);
345 :			if(mem_is_ok == -1) return -1;
346 :			}
347 :			else if(operation_code == REDUCE_D){
348 :			dist_blk_size = cursize;
349 :			num_dist_blk = THREADS*nbuckets;
350 :			reduceArr = upc_all_alloc(1,sizeof(double));
351 :			UPCMEM_OK(reduceArr);
352 :			if(mem_is_ok == -1) return -1;
353 :			}
354 :			else if(operation_code == PREFIX_REDUCE_D){
355 :			dist_blk_size = cursize;
356 :			num_dist_blk = THREADS*nbuckets;
357 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
358 :			UPCMEM_OK(prefixReduceArr);
359 :			if(mem_is_ok == -1) return -1;
360 :			}
361 :			else if(operation_code == REDUCE_LD){
362 :			dist_blk_size = cursize;
363 :			num_dist_blk = THREADS*nbuckets;
364 :			reduceArr = upc_all_alloc(1,sizeof(long double));
365 :			UPCMEM_OK(reduceArr);
366 :			if(mem_is_ok == -1) return -1;
367 :			}
368 :			else if(operation_code == PREFIX_REDUCE_LD){
369 :			dist_blk_size = cursize;
370 :			num_dist_blk = THREADS*nbuckets;
371 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
372 :			UPCMEM_OK(prefixReduceArr);
373 :			if(mem_is_ok == -1) return -1;
374 :			}
375 :
376 :			if(operation_code != BARRIER &&
377 :			operation_code != ALLALLOC &&
378 :			operation_code != FREE){
379 :			distArr = upc_all_alloc(num_dist_blk,dist_blk_size);
380 :			UPCMEM_OK(distArr);
381 :			if(mem_is_ok == -1) return -1;
382 :			}
383 :
384 :			}
385 :
386 :			return 0;
387 :
388 :			}
389 :
390 :			void free_arrays(int operation_code){
391 :			/*
392 :			Free p2p arrays
393 :			*/
394 :			if (p2poperation(operation_code)) {
395 :			free(p2pLocalArr);
396 :			if(operation_code == SMEMCPY || operation_code == MEMMOVE){
397 :			free(p2pLocalArr2);
398 :			}
399 :			else{
400 :			if (MYTHREAD == 0){
401 :			upc_free(p2pDistArr);
402 :	dalvarez	7	#if defined (ASYNC_MEM_TEST) || defined (ASYNCI_MEM_TEST)
403 :	dalvarez	1	if(operation_code == MEMCPY || operation_code == LMEMCPY ||
404 :	dalvarez	7	operation_code == AMEMCPY || operation_code == ALMEMCPY ||
405 :			operation_code == AIMEMCPY || operation_code == AILMEMCPY){
406 :	dalvarez	1	#else
407 :			if(operation_code == MEMCPY || operation_code == LMEMCPY){
408 :			#endif
409 :			upc_free(p2pDistArr2);
410 :			}
411 :			}
412 :			}
413 :			}
414 :			/*
415 :			Free collective arrays
416 :			*/
417 :			else{
418 :			if(MYTHREAD == 0){
419 :			if(operation_code == BROADCAST){
420 :			upc_free(broadcastArr);
421 :			}
422 :			else if(operation_code == SCATTER){
423 :			upc_free(scatterArr);
424 :			}
425 :			else if(operation_code == GATHER){
426 :			upc_free(gatherArr);
427 :			}
428 :			else if(operation_code == GATHERALL){
429 :			upc_free(gatherallArr);
430 :			}
431 :			else if(operation_code == EXCHANGE){
432 :			upc_free(exchangeArr);
433 :			}
434 :			else if(operation_code == PERMUTE){
435 :			upc_free(permuteArr);
436 :			}
437 :			else if(operation_code == REDUCE_C
438 :			|| operation_code == REDUCE_UC
439 :			|| operation_code == REDUCE_S
440 :			|| operation_code == REDUCE_US
441 :			|| operation_code == REDUCE_I
442 :			|| operation_code == REDUCE_UI
443 :			|| operation_code == REDUCE_L
444 :			|| operation_code == REDUCE_UL
445 :			|| operation_code == REDUCE_F
446 :			|| operation_code == REDUCE_D
447 :			|| operation_code == REDUCE_LD){
448 :			upc_free(reduceArr);
449 :			}
450 :			else if(operation_code == PREFIX_REDUCE_C
451 :			|| operation_code == PREFIX_REDUCE_UC
452 :			|| operation_code == PREFIX_REDUCE_S
453 :			|| operation_code == PREFIX_REDUCE_US
454 :			|| operation_code == PREFIX_REDUCE_I
455 :			|| operation_code == PREFIX_REDUCE_UI
456 :			|| operation_code == PREFIX_REDUCE_L
457 :			|| operation_code == PREFIX_REDUCE_UL
458 :			|| operation_code == PREFIX_REDUCE_F
459 :			|| operation_code == PREFIX_REDUCE_D
460 :			|| operation_code == PREFIX_REDUCE_LD){
461 :			upc_free(prefixReduceArr);
462 :			}
463 :
464 :			if(operation_code != BARRIER &&
465 :			operation_code != ALLALLOC &&
466 :			operation_code != FREE){
467 :			upc_free(distArr);
468 :			}
469 :			}
470 :			}
471 :			}

---

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