Karamelo  714599e9
Parallel Material Point Method Simulator
memory.h
1 /* -*- c++ -*- ----------------------------------------------------------
2  *
3  * *** Karamelo ***
4  * Parallel Material Point Method Simulator
5  *
6  * Copyright (2019) Alban de Vaucorbeil, alban.devaucorbeil@monash.edu
7  * Materials Science and Engineering, Monash University
8  * Clayton VIC 3800, Australia
9 
10  * This software is distributed under the GNU General Public License.
11  *
12  * ----------------------------------------------------------------------- */
13 
14 #ifndef MPM_MEMORY_H
15 #define MPM_MEMORY_H
16 
17 #include "mpmtype.h"
18 #include "pointers.h"
19 
29 class Memory : protected Pointers {
30  public:
31  Memory(class MPM *);
32 
33  void *smalloc(bigint n, string);
34  void *srealloc(void *, bigint n, string);
35  void sfree(void *);
36  void fail(string);
37 
38 /* ----------------------------------------------------------------------
39  create a 1d array
40 ------------------------------------------------------------------------- */
41 
42  template <typename TYPE>
43  TYPE *create(TYPE *&array, int n, string name)
44  {
45  bigint nbytes = ((bigint) sizeof(TYPE)) * n;
46  array = (TYPE *) smalloc(nbytes,name);
47  return array;
48  }
49 
50  template <typename TYPE>
51  TYPE **create(TYPE **&array, int n, string name)
52  {fail(name); return NULL;}
53 
54 /* ----------------------------------------------------------------------
55  grow or shrink 1d array
56 ------------------------------------------------------------------------- */
57 
58  template <typename TYPE>
59  TYPE *grow(TYPE *&array, int n, string name)
60  {
61  if (array == NULL) return create(array,n,name);
62 
63  bigint nbytes = ((bigint) sizeof(TYPE)) * n;
64  array = (TYPE *) srealloc(array,nbytes,name);
65  return array;
66  }
67 
68  template <typename TYPE>
69  TYPE **grow(TYPE **&array, int n, string name)
70  {fail(name); return NULL;}
71 
72 /* ----------------------------------------------------------------------
73  destroy a 1d array
74 ------------------------------------------------------------------------- */
75 
76  template <typename TYPE>
77  void destroy(TYPE *array)
78  {sfree(array);}
79 
80 /* ----------------------------------------------------------------------
81  create a 1d array with index from nlo to nhi inclusive
82  cannot grow it
83 ------------------------------------------------------------------------- */
84 
85  template <typename TYPE>
86  TYPE *create1d_offset(TYPE *&array, int nlo, int nhi, string name)
87  {
88  bigint nbytes = ((bigint) sizeof(TYPE)) * (nhi-nlo+1);
89  array = (TYPE *) smalloc(nbytes,name);
90  array -= nlo;
91  return array;
92  }
93 
94  template <typename TYPE>
95  TYPE **create1d_offset(TYPE **&array, int nlo, int nhi, string name)
96  {fail(name); return NULL;}
97 
98 /* ----------------------------------------------------------------------
99  destroy a 1d array with index offset
100 ------------------------------------------------------------------------- */
101 
102  template <typename TYPE>
103  void destroy1d_offset(TYPE *array, int offset)
104  {
105  if (array) sfree(&array[offset]);
106  }
107 
108 /* ----------------------------------------------------------------------
109  create a 2d array
110 ------------------------------------------------------------------------- */
111 
112  template <typename TYPE>
113  TYPE **create(TYPE **&array, int n1, int n2, string name)
114  {
115  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
116  TYPE *data = (TYPE *) smalloc(nbytes,name);
117  nbytes = ((bigint) sizeof(TYPE *)) * n1;
118  array = (TYPE **) smalloc(nbytes,name);
119 
120  bigint n = 0;
121  for (int i = 0; i < n1; i++) {
122  array[i] = &data[n];
123  n += n2;
124  }
125  return array;
126  }
127 
128  template <typename TYPE>
129  TYPE ***create(TYPE ***&array, int n1, int n2, string name)
130  {fail(name); return NULL;}
131 
132 /* ----------------------------------------------------------------------
133  grow or shrink 1st dim of a 2d array
134  last dim must stay the same
135 ------------------------------------------------------------------------- */
136 
137  template <typename TYPE>
138  TYPE **grow(TYPE **&array, int n1, int n2, string name)
139  {
140  if (array == NULL) return create(array,n1,n2,name);
141 
142  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
143  TYPE *data = (TYPE *) srealloc(array[0],nbytes,name);
144  nbytes = ((bigint) sizeof(TYPE *)) * n1;
145  array = (TYPE **) srealloc(array,nbytes,name);
146 
147  bigint n = 0;
148  for (int i = 0; i < n1; i++) {
149  array[i] = &data[n];
150  n += n2;
151  }
152  return array;
153  }
154 
155  template <typename TYPE>
156  TYPE ***grow(TYPE ***&array, int n1, int n2, string name)
157  {fail(name); return NULL;}
158 
159 /* ----------------------------------------------------------------------
160  destroy a 2d array
161 ------------------------------------------------------------------------- */
162 
163  template <typename TYPE>
164  void destroy(TYPE **array)
165  {
166  if (array == NULL) return;
167  sfree(array[0]);
168  sfree(array);
169  }
170 
171 /* ----------------------------------------------------------------------
172  create a 2d array with a ragged 2nd dimension
173 ------------------------------------------------------------------------- */
174 
175  template <typename TYPE>
176  TYPE **create_ragged(TYPE **&array, int n1, int *n2, string name)
177  {
178  bigint n2sum = 0;
179  for (int i = 0; i < n1; i++) n2sum += n2[i];
180 
181  bigint nbytes = ((bigint) sizeof(TYPE)) * n2sum;
182  TYPE *data = (TYPE *) smalloc(nbytes,name);
183  nbytes = ((bigint) sizeof(TYPE *)) * n1;
184  array = (TYPE **) smalloc(nbytes,name);
185 
186  bigint n = 0;
187  for (int i = 0; i < n1; i++) {
188  array[i] = &data[n];
189  n += n2[i];
190  }
191  return array;
192  }
193 
194  template <typename TYPE>
195  TYPE ***create_ragged(TYPE ***&array, int n1, int *n2, string name)
196  {fail(name); return NULL;}
197 
198 /* ----------------------------------------------------------------------
199  create a 2d array with 2nd index from n2lo to n2hi inclusive
200  cannot grow it
201 ------------------------------------------------------------------------- */
202 
203  template <typename TYPE>
204  TYPE **create2d_offset(TYPE **&array, int n1, int n2lo, int n2hi,
205  string name)
206  {
207  int n2 = n2hi - n2lo + 1;
208  create(array,n1,n2,name);
209  for (int i = 0; i < n1; i++) array[i] -= n2lo;
210  return array;
211  }
212 
213  template <typename TYPE>
214  TYPE ***create2d_offset(TYPE ***&array, int n1, int n2lo, int n2hi,
215  string name) {fail(name); return NULL;}
216 
217 /* ----------------------------------------------------------------------
218  destroy a 2d array with 2nd index offset
219 ------------------------------------------------------------------------- */
220 
221  template <typename TYPE>
222  void destroy2d_offset(TYPE **array, int offset)
223  {
224  if (array == NULL) return;
225  sfree(&array[0][offset]);
226  sfree(array);
227  }
228 
229 /* ----------------------------------------------------------------------
230  create a 3d array
231 ------------------------------------------------------------------------- */
232 
233  template <typename TYPE>
234  TYPE ***create(TYPE ***&array, int n1, int n2, int n3, string name)
235  {
236  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
237  TYPE *data = (TYPE *) smalloc(nbytes,name);
238  nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
239  TYPE **plane = (TYPE **) smalloc(nbytes,name);
240  nbytes = ((bigint) sizeof(TYPE **)) * n1;
241  array = (TYPE ***) smalloc(nbytes,name);
242 
243  int i,j;
244  bigint m;
245  bigint n = 0;
246  for (i = 0; i < n1; i++) {
247  m = ((bigint) i) * n2;
248  array[i] = &plane[m];
249  for (j = 0; j < n2; j++) {
250  plane[m+j] = &data[n];
251  n += n3;
252  }
253  }
254  return array;
255  }
256 
257  template <typename TYPE>
258  TYPE ****create(TYPE ****&array, int n1, int n2, int n3, string name)
259  {fail(name); return NULL;}
260 
261 /* ----------------------------------------------------------------------
262  grow or shrink 1st dim of a 3d array
263  last 2 dims must stay the same
264 ------------------------------------------------------------------------- */
265 
266  template <typename TYPE>
267  TYPE ***grow(TYPE ***&array, int n1, int n2, int n3, string name)
268  {
269  if (array == NULL) return create(array,n1,n2,n3,name);
270 
271  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
272  TYPE *data = (TYPE *) srealloc(array[0][0],nbytes,name);
273  nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
274  TYPE **plane = (TYPE **) srealloc(array[0],nbytes,name);
275  nbytes = ((bigint) sizeof(TYPE **)) * n1;
276  array = (TYPE ***) srealloc(array,nbytes,name);
277 
278  int i,j;
279  bigint m;
280  bigint n = 0;
281  for (i = 0; i < n1; i++) {
282  m = ((bigint) i) * n2;
283  array[i] = &plane[m];
284  for (j = 0; j < n2; j++) {
285  plane[m+j] = &data[n];
286  n += n3;
287  }
288  }
289  return array;
290  }
291 
292  template <typename TYPE>
293  TYPE ****grow(TYPE ****&array, int n1, int n2, int n3, string name)
294  {fail(name); return NULL;}
295 
296 /* ----------------------------------------------------------------------
297  destroy a 3d array
298 ------------------------------------------------------------------------- */
299 
300  template <typename TYPE>
301  void destroy(TYPE ***array)
302  {
303  if (array == NULL) return;
304  sfree(array[0][0]);
305  sfree(array[0]);
306  sfree(array);
307  }
308 
309 /* ----------------------------------------------------------------------
310  create a 3d array with 1st index from n1lo to n1hi inclusive
311  cannot grow it
312 ------------------------------------------------------------------------- */
313 
314  template <typename TYPE>
315  TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
316  int n2, int n3, string name)
317  {
318  int n1 = n1hi - n1lo + 1;
319  create(array,n1,n2,n3,name);
320  array -= n1lo;
321  return array;
322  }
323 
324  template <typename TYPE>
325  TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
326  int n2, int n3, string name)
327  {fail(name); return NULL;}
328 
329 /* ----------------------------------------------------------------------
330  free a 3d array with 1st index offset
331 ------------------------------------------------------------------------- */
332 
333  template <typename TYPE>
334  void destroy3d_offset(TYPE ***array, int offset)
335  {
336  if (array) destroy(&array[offset]);
337  }
338 
339 /* ----------------------------------------------------------------------
340  create a 3d array with
341  1st index from n1lo to n1hi inclusive,
342  2nd index from n2lo to n2hi inclusive,
343  3rd index from n3lo to n3hi inclusive
344  cannot grow it
345 ------------------------------------------------------------------------- */
346 
347  template <typename TYPE>
348  TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
349  int n2lo, int n2hi, int n3lo, int n3hi,
350  string name)
351  {
352  int n1 = n1hi - n1lo + 1;
353  int n2 = n2hi - n2lo + 1;
354  int n3 = n3hi - n3lo + 1;
355  create(array,n1,n2,n3,name);
356 
357  bigint m = ((bigint) n1) * n2;
358  for (bigint i = 0; i < m; i++) array[0][i] -= n3lo;
359  for (int i = 0; i < n1; i++) array[i] -= n2lo;
360  array -= n1lo;
361  return array;
362  }
363 
364  template <typename TYPE>
365  TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
366  int n2lo, int n2hi, int n3lo, int n3hi,
367  string name)
368  {fail(name); return NULL;}
369 
370 /* ----------------------------------------------------------------------
371  free a 3d array with all 3 indices offset
372 ------------------------------------------------------------------------- */
373 
374  template <typename TYPE>
375  void destroy3d_offset(TYPE ***array,
376  int n1_offset, int n2_offset, int n3_offset)
377  {
378  if (array == NULL) return;
379  sfree(&array[n1_offset][n2_offset][n3_offset]);
380  sfree(&array[n1_offset][n2_offset]);
381  sfree(&array[n1_offset]);
382  }
383 
384 /* ----------------------------------------------------------------------
385  create a 4d array
386 ------------------------------------------------------------------------- */
387 
388  template <typename TYPE>
389  TYPE ****create(TYPE ****&array, int n1, int n2, int n3, int n4,
390  string name)
391  {
392  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
393  TYPE *data = (TYPE *) smalloc(nbytes,name);
394  nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3;
395  TYPE **cube = (TYPE **) smalloc(nbytes,name);
396  nbytes = ((bigint) sizeof(TYPE **)) * n1*n2;
397  TYPE ***plane = (TYPE ***) smalloc(nbytes,name);
398  nbytes = ((bigint) sizeof(TYPE ***)) * n1;
399  array = (TYPE ****) smalloc(nbytes,name);
400 
401  int i,j,k;
402  bigint m1,m2;
403  bigint n = 0;
404  for (i = 0; i < n1; i++) {
405  m2 = ((bigint) i) * n2;
406  array[i] = &plane[m2];
407  for (j = 0; j < n2; j++) {
408  m1 = ((bigint) i) * n2 + j;
409  m2 = ((bigint) i) * n2*n3 + j*n3;
410  plane[m1] = &cube[m2];
411  for (k = 0; k < n3; k++) {
412  m1 = ((bigint) i) * n2*n3 + j*n3 + k;
413  cube[m1] = &data[n];
414  n += n4;
415  }
416  }
417  }
418  return array;
419  }
420 
421  template <typename TYPE>
422  TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
423  string name)
424  {fail(name); return NULL;}
425 
426 /* ----------------------------------------------------------------------
427  destroy a 4d array
428 ------------------------------------------------------------------------- */
429 
430  template <typename TYPE>
431  void destroy(TYPE ****array)
432  {
433  if (array == NULL) return;
434  sfree(array[0][0][0]);
435  sfree(array[0][0]);
436  sfree(array[0]);
437  sfree(array);
438  }
439 
440 /* ----------------------------------------------------------------------
441  create a 4d array with indices
442  2nd index from n2lo to n2hi inclusive
443  3rd index from n3lo to n3hi inclusive
444  4th index from n4lo to n4hi inclusive
445  cannot grow it
446 ------------------------------------------------------------------------- */
447 
448  template <typename TYPE>
449  TYPE ****create4d_offset(TYPE ****&array, int n1, int n2lo, int n2hi,
450  int n3lo, int n3hi, int n4lo, int n4hi,
451  string name)
452  {
453  int n2 = n2hi - n2lo + 1;
454  int n3 = n3hi - n3lo + 1;
455  int n4 = n4hi - n4lo + 1;
456  create(array,n1,n2,n3,n4,name);
457 
458  bigint m = ((bigint) n1) * n2 * n3;
459  for (bigint i = 0; i < m; i++) array[0][0][i] -= n4lo;
460  m = ((bigint) n1) * n2;
461  for (bigint i = 0; i < m; i++) array [0][i] -= n3lo;
462  for (int i = 0; i < n1; i++) array[i] -= n2lo;
463  return array;
464  }
465 
466  template <typename TYPE>
467  TYPE ****create4d_offset(TYPE *****&array, int n1, int n2lo, int n2hi,
468  int n3lo, int n3hi, int n4lo, int n4hi,
469  string name)
470  {fail(name); return NULL;}
471 
472 /* ----------------------------------------------------------------------
473  free a 4d array with indices 2,3, and 4 offset
474 ------------------------------------------------------------------------- */
475 
476  template <typename TYPE>
477  void destroy4d_offset(TYPE ****array,
478  int n2_offset, int n3_offset, int n4_offset)
479  {
480  if (array == NULL) return;
481  sfree(&array[0][n2_offset][n3_offset][n4_offset]);
482  sfree(&array[0][n2_offset][n3_offset]);
483  sfree(&array[0][n2_offset]);
484  sfree(array);
485  }
486 
487 /* ----------------------------------------------------------------------
488  create a 5d array
489 ------------------------------------------------------------------------- */
490 
491  template <typename TYPE>
492  TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
493  int n5, string name)
494  {
495  bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4*n5;
496  TYPE *data = (TYPE *) smalloc(nbytes,name);
497  nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3*n4;
498  TYPE **level4 = (TYPE **) smalloc(nbytes,name);
499  nbytes = ((bigint) sizeof(TYPE **)) * n1*n2*n3;
500  TYPE ***level3 = (TYPE ***) smalloc(nbytes,name);
501  nbytes = ((bigint) sizeof(TYPE ***)) * n1*n2;
502  TYPE ****level2 = (TYPE ****) smalloc(nbytes,name);
503  nbytes = ((bigint) sizeof(TYPE ****)) * n1;
504  array = (TYPE *****) smalloc(nbytes,name);
505 
506  int i,j,k,l;
507  bigint m1,m2;
508  bigint n = 0;
509  for (i = 0; i < n1; i++) {
510  m2 = ((bigint) i) * n2;
511  array[i] = &level2[m2];
512  for (j = 0; j < n2; j++) {
513  m1 = ((bigint) i) * n2 + j;
514  m2 = ((bigint) i) * n2*n3 + ((bigint) j) * n3;
515  level2[m1] = &level3[m2];
516  for (k = 0; k < n3; k++) {
517  m1 = ((bigint) i) * n2*n3 + ((bigint) j) * n3 + k;
518  m2 = ((bigint) i) * n2*n3*n4 +
519  ((bigint) j) * n3*n4 + ((bigint) k) * n4;
520  level3[m1] = &level4[m2];
521  for (l = 0; l < n4; l++) {
522  m1 = ((bigint) i) * n2*n3*n4 +
523  ((bigint) j) * n3*n4 + ((bigint) k) * n4 + l;
524  level4[m1] = &data[n];
525  n += n5;
526  }
527  }
528  }
529  }
530  return array;
531  }
532 
533  template <typename TYPE>
534  TYPE ******create(TYPE ******&array, int n1, int n2, int n3, int n4,
535  int n5, string name)
536  {fail(name); return NULL;}
537 
538 /* ----------------------------------------------------------------------
539  destroy a 5d array
540 ------------------------------------------------------------------------- */
541 
542  template <typename TYPE>
543  void destroy(TYPE *****array)
544  {
545  if (array == NULL) return;
546  sfree(array[0][0][0][0]);
547  sfree(array[0][0][0]);
548  sfree(array[0][0]);
549  sfree(array[0]);
550  sfree(array);
551  }
552 
553 /* ----------------------------------------------------------------------
554  memory usage of arrays, including pointers
555 ------------------------------------------------------------------------- */
556 
557  template <typename TYPE>
558  bigint usage(TYPE *array, int n)
559  {
560  (void) array;
561  bigint bytes = ((bigint) sizeof(TYPE)) * n;
562  return bytes;
563  }
564 
565  template <typename TYPE>
566  bigint usage(TYPE **array, int n1, int n2)
567  {
568  (void) array;
569  bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2;
570  bytes += ((bigint) sizeof(TYPE *)) * n1;
571  return bytes;
572  }
573 
574  template <typename TYPE>
575  bigint usage(TYPE ***array, int n1, int n2, int n3)
576  {
577  (void) array;
578  bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
579  bytes += ((bigint) sizeof(TYPE *)) * n1*n2;
580  bytes += ((bigint) sizeof(TYPE **)) * n1;
581  return bytes;
582  }
583 
584  template <typename TYPE>
585  bigint usage(TYPE ****array, int n1, int n2, int n3, int n4)
586  {
587  (void) array;
588  bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
589  bytes += ((bigint) sizeof(TYPE *)) * n1*n2*n3;
590  bytes += ((bigint) sizeof(TYPE **)) * n1*n2;
591  bytes += ((bigint) sizeof(TYPE ***)) * n1;
592  return bytes;
593  }
594 };
595 
596 
597 #endif
Memory::sfree
void sfree(void *)
Safe free.
Definition: memory.cpp:71
MPM
Definition: mpm.h:29
Memory::srealloc
void * srealloc(void *, bigint n, string)
Safe reallocation.
Definition: memory.cpp:52
Memory
Definition: memory.h:29
Pointers
Definition: pointers.h:29
Memory::smalloc
void * smalloc(bigint n, string)
Safe malloc.
Definition: memory.cpp:30
Memory::fail
void fail(string)
Erroneous usage of templated create/grow functions.
Definition: memory.cpp:81