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

Parent Directory | Revision Log

---

Revision 1 - (view) (download)

1 :	dalvarez	1	/*****************************************************************************/
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 :
29 :			/*****************************************************************************/
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 :			/* (UPCPU­Project -> UPC Performance and Usability Project) */
39 :			/* */
40 :			/*****************************************************************************/
41 :
42 :			/*****************************************************************************
43 :
44 :			For further documentation, see
45 :
46 :			[1] Files under doc/
47 :
48 :			******************************************************************************/
49 :
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 :			#ifdef ASYNC_MEM_TEST
136 :			if(operation_code == MEMCPY || operation_code == LMEMCPY ||
137 :			operation_code == AMEMCPY || operation_code == ALMEMCPY){
138 :			#else
139 :			if(operation_code == MEMCPY || operation_code == LMEMCPY){
140 :			#endif
141 :			p2pDistArr2 = upc_all_alloc(THREADS,nbytes);
142 :			UPCMEM_OK(p2pDistArr);
143 :			if(mem_is_ok == -1) return -1;
144 :			}
145 :			}
146 :			}
147 :			/*
148 :			Setup collective arrays
149 :			*/
150 :			else{
151 :			size_t dist_blk_size = 0;
152 :			size_t num_dist_blk = 0;
153 :			if(operation_code == BROADCAST){
154 :			dist_blk_size = cursize;
155 :			num_dist_blk = THREADS*nbuckets;
156 :			broadcastArr = upc_all_alloc(1,nbytes);
157 :			UPCMEM_OK(broadcastArr);
158 :			if(mem_is_ok == -1) return -1;
159 :			}
160 :			else if(operation_code == SCATTER){
161 :			dist_blk_size = cursize;
162 :			num_dist_blk = THREADS*nbuckets;
163 :			scatterArr = upc_all_alloc(1,nbytes*THREADS);
164 :			UPCMEM_OK(scatterArr);
165 :			if(mem_is_ok == -1) return -1;
166 :			}
167 :			else if(operation_code == GATHER){
168 :			dist_blk_size = cursize;
169 :			num_dist_blk = THREADS*nbuckets;
170 :			gatherArr = upc_all_alloc(1,nbytes*THREADS);
171 :			UPCMEM_OK(gatherArr);
172 :			if(mem_is_ok == -1) return -1;
173 :			}
174 :			else if(operation_code == GATHERALL){
175 :			dist_blk_size = cursize;
176 :			num_dist_blk = THREADS*nbuckets;
177 :			gatherallArr = upc_all_alloc(num_dist_blk,cursize*THREADS);
178 :			UPCMEM_OK(gatherallArr);
179 :			if(mem_is_ok == -1) return -1;
180 :			}
181 :			else if(operation_code == EXCHANGE){
182 :			dist_blk_size = cursize*THREADS;
183 :			num_dist_blk = THREADS*nbuckets;
184 :			exchangeArr = upc_all_alloc(num_dist_blk,dist_blk_size);
185 :			UPCMEM_OK(exchangeArr);
186 :			if(mem_is_ok == -1) return -1;
187 :			}
188 :			else if(operation_code == PERMUTE){
189 :			dist_blk_size = cursize;
190 :			num_dist_blk = THREADS*nbuckets;
191 :			permuteArr = upc_all_alloc(num_dist_blk,dist_blk_size);
192 :			UPCMEM_OK(permuteArr);
193 :			if(mem_is_ok == -1) return -1;
194 :			}
195 :			else if(operation_code == REDUCE_C){
196 :			dist_blk_size = cursize;
197 :			num_dist_blk = THREADS*nbuckets;
198 :			reduceArr = upc_all_alloc(1,sizeof(char));
199 :			UPCMEM_OK(reduceArr);
200 :			if(mem_is_ok == -1) return -1;
201 :			}
202 :			else if(operation_code == PREFIX_REDUCE_C){
203 :			dist_blk_size = cursize;
204 :			num_dist_blk = THREADS*nbuckets;
205 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
206 :			UPCMEM_OK(prefixReduceArr);
207 :			if(mem_is_ok == -1) return -1;
208 :			}
209 :			else if(operation_code == REDUCE_UC){
210 :			dist_blk_size = cursize;
211 :			num_dist_blk = THREADS*nbuckets;
212 :			reduceArr = upc_all_alloc(1,sizeof(unsigned char));
213 :			UPCMEM_OK(reduceArr);
214 :			if(mem_is_ok == -1) return -1;
215 :			}
216 :			else if(operation_code == PREFIX_REDUCE_UC){
217 :			dist_blk_size = cursize;
218 :			num_dist_blk = THREADS*nbuckets;
219 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
220 :			UPCMEM_OK(prefixReduceArr);
221 :			if(mem_is_ok == -1) return -1;
222 :			}
223 :			else if(operation_code == REDUCE_S){
224 :			dist_blk_size = cursize;
225 :			num_dist_blk = THREADS*nbuckets;
226 :			reduceArr = upc_all_alloc(1,sizeof(short));
227 :			UPCMEM_OK(reduceArr);
228 :			if(mem_is_ok == -1) return -1;
229 :			}
230 :			else if(operation_code == PREFIX_REDUCE_S){
231 :			dist_blk_size = cursize;
232 :			num_dist_blk = THREADS*nbuckets;
233 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
234 :			UPCMEM_OK(prefixReduceArr);
235 :			if(mem_is_ok == -1) return -1;
236 :			}
237 :			else if(operation_code == REDUCE_US){
238 :			dist_blk_size = cursize;
239 :			num_dist_blk = THREADS*nbuckets;
240 :			reduceArr = upc_all_alloc(1,sizeof(unsigned short));
241 :			UPCMEM_OK(reduceArr);
242 :			if(mem_is_ok == -1) return -1;
243 :			}
244 :			else if(operation_code == PREFIX_REDUCE_US){
245 :			dist_blk_size = cursize;
246 :			num_dist_blk = THREADS*nbuckets;
247 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
248 :			UPCMEM_OK(prefixReduceArr);
249 :			if(mem_is_ok == -1) return -1;
250 :			}
251 :			else if(operation_code == REDUCE_I){
252 :			dist_blk_size = cursize;
253 :			num_dist_blk = THREADS*nbuckets;
254 :			reduceArr = upc_all_alloc(1,sizeof(int));
255 :			UPCMEM_OK(reduceArr);
256 :			if(mem_is_ok == -1) return -1;
257 :			}
258 :			else if(operation_code == PREFIX_REDUCE_I){
259 :			dist_blk_size = cursize;
260 :			num_dist_blk = THREADS*nbuckets;
261 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
262 :			UPCMEM_OK(prefixReduceArr);
263 :			if(mem_is_ok == -1) return -1;
264 :			}
265 :			else if(operation_code == REDUCE_UI){
266 :			dist_blk_size = cursize;
267 :			num_dist_blk = THREADS*nbuckets;
268 :			reduceArr = upc_all_alloc(1,sizeof(unsigned int));
269 :			UPCMEM_OK(reduceArr);
270 :			if(mem_is_ok == -1) return -1;
271 :			}
272 :			else if(operation_code == PREFIX_REDUCE_UI){
273 :			dist_blk_size = cursize;
274 :			num_dist_blk = THREADS*nbuckets;
275 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
276 :			UPCMEM_OK(prefixReduceArr);
277 :			if(mem_is_ok == -1) return -1;
278 :			}
279 :			else if(operation_code == REDUCE_L){
280 :			dist_blk_size = cursize;
281 :			num_dist_blk = THREADS*nbuckets;
282 :			reduceArr = upc_all_alloc(1,sizeof(long));
283 :			UPCMEM_OK(reduceArr);
284 :			if(mem_is_ok == -1) return -1;
285 :			}
286 :			else if(operation_code == PREFIX_REDUCE_L){
287 :			dist_blk_size = cursize;
288 :			num_dist_blk = THREADS*nbuckets;
289 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
290 :			UPCMEM_OK(prefixReduceArr);
291 :			if(mem_is_ok == -1) return -1;
292 :			}
293 :			else if(operation_code == REDUCE_UL){
294 :			dist_blk_size = cursize;
295 :			num_dist_blk = THREADS*nbuckets;
296 :			reduceArr = upc_all_alloc(1,sizeof(unsigned long));
297 :			UPCMEM_OK(reduceArr);
298 :			if(mem_is_ok == -1) return -1;
299 :			}
300 :			else if(operation_code == PREFIX_REDUCE_UL){
301 :			dist_blk_size = cursize;
302 :			num_dist_blk = THREADS*nbuckets;
303 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
304 :			UPCMEM_OK(prefixReduceArr);
305 :			if(mem_is_ok == -1) return -1;
306 :			}
307 :			else if(operation_code == REDUCE_F){
308 :			dist_blk_size = cursize;
309 :			num_dist_blk = THREADS*nbuckets;
310 :			reduceArr = upc_all_alloc(1,sizeof(float));
311 :			UPCMEM_OK(reduceArr);
312 :			if(mem_is_ok == -1) return -1;
313 :			}
314 :			else if(operation_code == PREFIX_REDUCE_F){
315 :			dist_blk_size = cursize;
316 :			num_dist_blk = THREADS*nbuckets;
317 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
318 :			UPCMEM_OK(prefixReduceArr);
319 :			if(mem_is_ok == -1) return -1;
320 :			}
321 :			else if(operation_code == REDUCE_D){
322 :			dist_blk_size = cursize;
323 :			num_dist_blk = THREADS*nbuckets;
324 :			reduceArr = upc_all_alloc(1,sizeof(double));
325 :			UPCMEM_OK(reduceArr);
326 :			if(mem_is_ok == -1) return -1;
327 :			}
328 :			else if(operation_code == PREFIX_REDUCE_D){
329 :			dist_blk_size = cursize;
330 :			num_dist_blk = THREADS*nbuckets;
331 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
332 :			UPCMEM_OK(prefixReduceArr);
333 :			if(mem_is_ok == -1) return -1;
334 :			}
335 :			else if(operation_code == REDUCE_LD){
336 :			dist_blk_size = cursize;
337 :			num_dist_blk = THREADS*nbuckets;
338 :			reduceArr = upc_all_alloc(1,sizeof(long double));
339 :			UPCMEM_OK(reduceArr);
340 :			if(mem_is_ok == -1) return -1;
341 :			}
342 :			else if(operation_code == PREFIX_REDUCE_LD){
343 :			dist_blk_size = cursize;
344 :			num_dist_blk = THREADS*nbuckets;
345 :			prefixReduceArr = upc_all_alloc(num_dist_blk,dist_blk_size);
346 :			UPCMEM_OK(prefixReduceArr);
347 :			if(mem_is_ok == -1) return -1;
348 :			}
349 :
350 :			if(operation_code != BARRIER &&
351 :			operation_code != ALLALLOC &&
352 :			operation_code != FREE){
353 :			distArr = upc_all_alloc(num_dist_blk,dist_blk_size);
354 :			UPCMEM_OK(distArr);
355 :			if(mem_is_ok == -1) return -1;
356 :			}
357 :
358 :			}
359 :
360 :			return 0;
361 :
362 :			}
363 :
364 :			void free_arrays(int operation_code){
365 :			/*
366 :			Free p2p arrays
367 :			*/
368 :			if (p2poperation(operation_code)) {
369 :			free(p2pLocalArr);
370 :			if(operation_code == SMEMCPY || operation_code == MEMMOVE){
371 :			free(p2pLocalArr2);
372 :			}
373 :			else{
374 :			if (MYTHREAD == 0){
375 :			upc_free(p2pDistArr);
376 :			#ifdef ASYNC_MEM_TEST
377 :			if(operation_code == MEMCPY || operation_code == LMEMCPY ||
378 :			operation_code == AMEMCPY || operation_code == ALMEMCPY){
379 :			#else
380 :			if(operation_code == MEMCPY || operation_code == LMEMCPY){
381 :			#endif
382 :			upc_free(p2pDistArr2);
383 :			}
384 :			}
385 :			}
386 :			}
387 :			/*
388 :			Free collective arrays
389 :			*/
390 :			else{
391 :			if(MYTHREAD == 0){
392 :			if(operation_code == BROADCAST){
393 :			upc_free(broadcastArr);
394 :			}
395 :			else if(operation_code == SCATTER){
396 :			upc_free(scatterArr);
397 :			}
398 :			else if(operation_code == GATHER){
399 :			upc_free(gatherArr);
400 :			}
401 :			else if(operation_code == GATHERALL){
402 :			upc_free(gatherallArr);
403 :			}
404 :			else if(operation_code == EXCHANGE){
405 :			upc_free(exchangeArr);
406 :			}
407 :			else if(operation_code == PERMUTE){
408 :			upc_free(permuteArr);
409 :			}
410 :			else if(operation_code == REDUCE_C
411 :			|| operation_code == REDUCE_UC
412 :			|| operation_code == REDUCE_S
413 :			|| operation_code == REDUCE_US
414 :			|| operation_code == REDUCE_I
415 :			|| operation_code == REDUCE_UI
416 :			|| operation_code == REDUCE_L
417 :			|| operation_code == REDUCE_UL
418 :			|| operation_code == REDUCE_F
419 :			|| operation_code == REDUCE_D
420 :			|| operation_code == REDUCE_LD){
421 :			upc_free(reduceArr);
422 :			}
423 :			else if(operation_code == PREFIX_REDUCE_C
424 :			|| operation_code == PREFIX_REDUCE_UC
425 :			|| operation_code == PREFIX_REDUCE_S
426 :			|| operation_code == PREFIX_REDUCE_US
427 :			|| operation_code == PREFIX_REDUCE_I
428 :			|| operation_code == PREFIX_REDUCE_UI
429 :			|| operation_code == PREFIX_REDUCE_L
430 :			|| operation_code == PREFIX_REDUCE_UL
431 :			|| operation_code == PREFIX_REDUCE_F
432 :			|| operation_code == PREFIX_REDUCE_D
433 :			|| operation_code == PREFIX_REDUCE_LD){
434 :			upc_free(prefixReduceArr);
435 :			}
436 :
437 :			if(operation_code != BARRIER &&
438 :			operation_code != ALLALLOC &&
439 :			operation_code != FREE){
440 :			upc_free(distArr);
441 :			}
442 :			}
443 :			}
444 :			}

---

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