forked from lijiext/lammps
git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@11532 f3b2605a-c512-4ea7-a41b-209d697bcdaa
This commit is contained in:
sjplimp
parent
b28ce4b3bb
commit
82833b729f
734
src/memory.h
734
src/memory.h
|
|
@ -16,6 +16,9 @@
|
|||
|
||||
#include "lmptype.h"
|
||||
#include "pointers.h"
|
||||
#ifdef LMP_KOKKOS
|
||||
#include "kokkos_type.h"
|
||||
#endif
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
|
|
@ -28,10 +31,17 @@ class Memory : protected Pointers {
|
|||
void sfree(void *);
|
||||
void fail(const char *);
|
||||
|
||||
// Kokkos memory allocation functions
|
||||
|
||||
#ifdef LMP_KOKKOS
|
||||
#include "memory_kokkos.h"
|
||||
#endif
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create/grow/destroy vecs and multidim arrays with contiguous memory blocks
|
||||
only use with primitive data types, e.g. 1d vec of ints, 2d array of doubles
|
||||
cannot use with pointers, e.g. 1d vec of int*, due to mismatched destroy
|
||||
fail() prevents use with pointers,
|
||||
e.g. 1d vec of int*, due to mismatched destroy
|
||||
avoid use with non-primitive data types to avoid code bloat
|
||||
for these other cases, use smalloc/srealloc/sfree directly
|
||||
------------------------------------------------------------------------- */
|
||||
|
|
@ -41,42 +51,42 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE *create(TYPE *&array, int n, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n;
|
||||
array = (TYPE *) smalloc(nbytes,name);
|
||||
return array;
|
||||
}
|
||||
TYPE *create(TYPE *&array, int n, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n;
|
||||
array = (TYPE *) smalloc(nbytes,name);
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **create(TYPE **&array, int n, const char *name) {fail(name);}
|
||||
TYPE **create(TYPE **&array, int n, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
grow or shrink 1d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE *grow(TYPE *&array, int n, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n,name);
|
||||
TYPE *grow(TYPE *&array, int n, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n,name);
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n;
|
||||
array = (TYPE *) srealloc(array,nbytes,name);
|
||||
return array;
|
||||
}
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n;
|
||||
array = (TYPE *) srealloc(array,nbytes,name);
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **grow(TYPE **&array, int n, const char *name) {fail(name);}
|
||||
TYPE **grow(TYPE **&array, int n, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 1d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy(TYPE *array)
|
||||
{
|
||||
sfree(array);
|
||||
}
|
||||
void destroy(TYPE *array)
|
||||
{sfree(array);}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 1d array with index from nlo to nhi inclusive
|
||||
|
|
@ -84,51 +94,51 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE *create1d_offset(TYPE *&array, int nlo, int nhi, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * (nhi-nlo+1);
|
||||
array = (TYPE *) smalloc(nbytes,name);
|
||||
array -= nlo;
|
||||
return array;
|
||||
}
|
||||
TYPE *create1d_offset(TYPE *&array, int nlo, int nhi, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * (nhi-nlo+1);
|
||||
array = (TYPE *) smalloc(nbytes,name);
|
||||
array -= nlo;
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **create1d_offset(TYPE **&array, int nlo, int nhi, const char *name)
|
||||
{fail(name);}
|
||||
TYPE **create1d_offset(TYPE **&array, int nlo, int nhi, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 1d array with index offset
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy1d_offset(TYPE *array, int offset)
|
||||
{
|
||||
if (array) sfree(&array[offset]);
|
||||
}
|
||||
void destroy1d_offset(TYPE *array, int offset)
|
||||
{
|
||||
if (array) sfree(&array[offset]);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 2d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **create(TYPE **&array, int n1, int n2, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) smalloc(nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2;
|
||||
}
|
||||
return array;
|
||||
TYPE **create(TYPE **&array, int n1, int n2, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) smalloc(nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create(TYPE ***&array, int n1, int n2, const char *name)
|
||||
{fail(name);}
|
||||
TYPE ***create(TYPE ***&array, int n1, int n2, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
grow or shrink 1st dim of a 2d array
|
||||
|
|
@ -136,128 +146,128 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **grow(TYPE **&array, int n1, int n2, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n1,n2,name);
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
TYPE *data = (TYPE *) srealloc(array[0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) srealloc(array,nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2;
|
||||
}
|
||||
return array;
|
||||
TYPE **grow(TYPE **&array, int n1, int n2, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n1,n2,name);
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
TYPE *data = (TYPE *) srealloc(array[0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) srealloc(array,nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2;
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***grow(TYPE ***&array, int n1, int n2, const char *name)
|
||||
{fail(name);}
|
||||
|
||||
TYPE ***grow(TYPE ***&array, int n1, int n2, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 2d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy(TYPE **array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
void destroy(TYPE **array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 2d array with a ragged 2nd dimension
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **create_ragged(TYPE **&array, int n1, int *n2, const char *name)
|
||||
{
|
||||
bigint n2sum = 0;
|
||||
for (int i = 0; i < n1; i++) n2sum += n2[i];
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n2sum;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) smalloc(nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2[i];
|
||||
}
|
||||
return array;
|
||||
TYPE **create_ragged(TYPE **&array, int n1, int *n2, const char *name)
|
||||
{
|
||||
bigint n2sum = 0;
|
||||
for (int i = 0; i < n1; i++) n2sum += n2[i];
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n2sum;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1;
|
||||
array = (TYPE **) smalloc(nbytes,name);
|
||||
|
||||
bigint n = 0;
|
||||
for (int i = 0; i < n1; i++) {
|
||||
array[i] = &data[n];
|
||||
n += n2[i];
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create_ragged(TYPE ***&array, int n1, int *n2, const char *name)
|
||||
{fail(name);}
|
||||
|
||||
TYPE ***create_ragged(TYPE ***&array, int n1, int *n2, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 2d array with 2nd index from n2lo to n2hi inclusive
|
||||
cannot grow it
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE **create2d_offset(TYPE **&array, int n1, int n2lo, int n2hi,
|
||||
const char *name)
|
||||
{
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
create(array,n1,n2,name);
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
TYPE **create2d_offset(TYPE **&array, int n1, int n2lo, int n2hi,
|
||||
const char *name)
|
||||
{
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
create(array,n1,n2,name);
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create2d_offset(TYPE ***&array, int n1, int n2lo, int n2hi,
|
||||
const char *name) {fail(name);}
|
||||
|
||||
TYPE ***create2d_offset(TYPE ***&array, int n1, int n2lo, int n2hi,
|
||||
const char *name) {fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 2d array with 2nd index offset
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy2d_offset(TYPE **array, int offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[0][offset]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
void destroy2d_offset(TYPE **array, int offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[0][offset]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 3d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create(TYPE ***&array, int n1, int n2, int n3, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
TYPE **plane = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1;
|
||||
array = (TYPE ***) smalloc(nbytes,name);
|
||||
|
||||
int i,j;
|
||||
bigint m;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m = ((bigint) i) * n2;
|
||||
array[i] = &plane[m];
|
||||
for (j = 0; j < n2; j++) {
|
||||
plane[m+j] = &data[n];
|
||||
n += n3;
|
||||
}
|
||||
TYPE ***create(TYPE ***&array, int n1, int n2, int n3, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
TYPE **plane = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1;
|
||||
array = (TYPE ***) smalloc(nbytes,name);
|
||||
|
||||
int i,j;
|
||||
bigint m;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m = ((bigint) i) * n2;
|
||||
array[i] = &plane[m];
|
||||
for (j = 0; j < n2; j++) {
|
||||
plane[m+j] = &data[n];
|
||||
n += n3;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create(TYPE ****&array, int n1, int n2, int n3, const char *name)
|
||||
{fail(name);}
|
||||
TYPE ****create(TYPE ****&array, int n1, int n2, int n3, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
grow or shrink 1st dim of a 3d array
|
||||
|
|
@ -265,47 +275,47 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***grow(TYPE ***&array, int n1, int n2, int n3, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n1,n2,n3,name);
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
TYPE *data = (TYPE *) srealloc(array[0][0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
TYPE **plane = (TYPE **) srealloc(array[0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1;
|
||||
array = (TYPE ***) srealloc(array,nbytes,name);
|
||||
|
||||
int i,j;
|
||||
bigint m;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m = ((bigint) i) * n2;
|
||||
array[i] = &plane[m];
|
||||
for (j = 0; j < n2; j++) {
|
||||
plane[m+j] = &data[n];
|
||||
n += n3;
|
||||
}
|
||||
TYPE ***grow(TYPE ***&array, int n1, int n2, int n3, const char *name)
|
||||
{
|
||||
if (array == NULL) return create(array,n1,n2,n3,name);
|
||||
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
TYPE *data = (TYPE *) srealloc(array[0][0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
TYPE **plane = (TYPE **) srealloc(array[0],nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1;
|
||||
array = (TYPE ***) srealloc(array,nbytes,name);
|
||||
|
||||
int i,j;
|
||||
bigint m;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m = ((bigint) i) * n2;
|
||||
array[i] = &plane[m];
|
||||
for (j = 0; j < n2; j++) {
|
||||
plane[m+j] = &data[n];
|
||||
n += n3;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****grow(TYPE ****&array, int n1, int n2, int n3, const char *name)
|
||||
{fail(name);}
|
||||
TYPE ****grow(TYPE ****&array, int n1, int n2, int n3, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 3d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy(TYPE ***array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
void destroy(TYPE ***array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 3d array with 1st index from n1lo to n1hi inclusive
|
||||
|
|
@ -313,29 +323,29 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
|
||||
int n2, int n3, const char *name)
|
||||
{
|
||||
int n1 = n1hi - n1lo + 1;
|
||||
create(array,n1,n2,n3,name);
|
||||
array -= n1lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
|
||||
int n2, int n3, const char *name)
|
||||
{
|
||||
int n1 = n1hi - n1lo + 1;
|
||||
create(array,n1,n2,n3,name);
|
||||
array -= n1lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
|
||||
int n2, int n3, const char *name)
|
||||
{fail(name);}
|
||||
TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
|
||||
int n2, int n3, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
free a 3d array with 1st index offset
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy3d_offset(TYPE ***array, int offset)
|
||||
{
|
||||
if (array) destroy(&array[offset]);
|
||||
}
|
||||
void destroy3d_offset(TYPE ***array, int offset)
|
||||
{
|
||||
if (array) destroy(&array[offset]);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 3d array with
|
||||
|
|
@ -346,97 +356,97 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
|
||||
int n2lo, int n2hi, int n3lo, int n3hi,
|
||||
const char *name)
|
||||
{
|
||||
int n1 = n1hi - n1lo + 1;
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
int n3 = n3hi - n3lo + 1;
|
||||
create(array,n1,n2,n3,name);
|
||||
|
||||
bigint m = ((bigint) n1) * n2;
|
||||
for (bigint i = 0; i < m; i++) array[0][i] -= n3lo;
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
array -= n1lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
TYPE ***create3d_offset(TYPE ***&array, int n1lo, int n1hi,
|
||||
int n2lo, int n2hi, int n3lo, int n3hi,
|
||||
const char *name)
|
||||
{
|
||||
int n1 = n1hi - n1lo + 1;
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
int n3 = n3hi - n3lo + 1;
|
||||
create(array,n1,n2,n3,name);
|
||||
|
||||
bigint m = ((bigint) n1) * n2;
|
||||
for (bigint i = 0; i < m; i++) array[0][i] -= n3lo;
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
array -= n1lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
|
||||
int n2lo, int n2hi, int n3lo, int n3hi,
|
||||
const char *name)
|
||||
{fail(name);}
|
||||
TYPE ****create3d_offset(TYPE ****&array, int n1lo, int n1hi,
|
||||
int n2lo, int n2hi, int n3lo, int n3hi,
|
||||
const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
free a 3d array with all 3 indices offset
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy3d_offset(TYPE ***array,
|
||||
int n1_offset, int n2_offset, int n3_offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[n1_offset][n2_offset][n3_offset]);
|
||||
sfree(&array[n1_offset][n2_offset]);
|
||||
sfree(&array[n1_offset]);
|
||||
}
|
||||
|
||||
void destroy3d_offset(TYPE ***array,
|
||||
int n1_offset, int n2_offset, int n3_offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[n1_offset][n2_offset][n3_offset]);
|
||||
sfree(&array[n1_offset][n2_offset]);
|
||||
sfree(&array[n1_offset]);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 4d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create(TYPE ****&array, int n1, int n2, int n3, int n4,
|
||||
const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3;
|
||||
TYPE **cube = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1*n2;
|
||||
TYPE ***plane = (TYPE ***) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ***)) * n1;
|
||||
array = (TYPE ****) smalloc(nbytes,name);
|
||||
|
||||
int i,j,k;
|
||||
bigint m1,m2,m3;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m2 = ((bigint) i) * n2;
|
||||
array[i] = &plane[m2];
|
||||
for (j = 0; j < n2; j++) {
|
||||
m1 = ((bigint) i) * n2 + j;
|
||||
m2 = ((bigint) i) * n2*n3 + j*n3;
|
||||
plane[m1] = &cube[m2];
|
||||
for (k = 0; k < n3; k++) {
|
||||
m1 = ((bigint) i) * n2*n3 + j*n3 + k;
|
||||
cube[m1] = &data[n];
|
||||
n += n4;
|
||||
}
|
||||
TYPE ****create(TYPE ****&array, int n1, int n2, int n3, int n4,
|
||||
const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3;
|
||||
TYPE **cube = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1*n2;
|
||||
TYPE ***plane = (TYPE ***) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ***)) * n1;
|
||||
array = (TYPE ****) smalloc(nbytes,name);
|
||||
|
||||
int i,j,k;
|
||||
bigint m1,m2,m3;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m2 = ((bigint) i) * n2;
|
||||
array[i] = &plane[m2];
|
||||
for (j = 0; j < n2; j++) {
|
||||
m1 = ((bigint) i) * n2 + j;
|
||||
m2 = ((bigint) i) * n2*n3 + j*n3;
|
||||
plane[m1] = &cube[m2];
|
||||
for (k = 0; k < n3; k++) {
|
||||
m1 = ((bigint) i) * n2*n3 + j*n3 + k;
|
||||
cube[m1] = &data[n];
|
||||
n += n4;
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
|
||||
const char *name)
|
||||
{fail(name);}
|
||||
TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
|
||||
const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 4d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy(TYPE ****array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0][0]);
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
void destroy(TYPE ****array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0][0]);
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 4d array with indices
|
||||
|
|
@ -447,145 +457,147 @@ class Memory : protected Pointers {
|
|||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create4d_offset(TYPE ****&array, int n1, int n2lo, int n2hi,
|
||||
int n3lo, int n3hi, int n4lo, int n4hi,
|
||||
const char *name)
|
||||
{
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
int n3 = n3hi - n3lo + 1;
|
||||
int n4 = n4hi - n4lo + 1;
|
||||
create(array,n1,n2,n3,n4,name);
|
||||
|
||||
bigint m = ((bigint) n1) * n2 * n3;
|
||||
for (bigint i = 0; i < m; i++) array[0][0][i] -= n4lo;
|
||||
m = ((bigint) n1) * n2;
|
||||
for (bigint i = 0; i < m; i++) array [0][i] -= n3lo;
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
TYPE ****create4d_offset(TYPE ****&array, int n1, int n2lo, int n2hi,
|
||||
int n3lo, int n3hi, int n4lo, int n4hi,
|
||||
const char *name)
|
||||
{
|
||||
int n2 = n2hi - n2lo + 1;
|
||||
int n3 = n3hi - n3lo + 1;
|
||||
int n4 = n4hi - n4lo + 1;
|
||||
create(array,n1,n2,n3,n4,name);
|
||||
|
||||
bigint m = ((bigint) n1) * n2 * n3;
|
||||
for (bigint i = 0; i < m; i++) array[0][0][i] -= n4lo;
|
||||
m = ((bigint) n1) * n2;
|
||||
for (bigint i = 0; i < m; i++) array [0][i] -= n3lo;
|
||||
for (int i = 0; i < n1; i++) array[i] -= n2lo;
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ****create4d_offset(TYPE *****&array, int n1, int n2lo, int n2hi,
|
||||
int n3lo, int n3hi, int n4lo, int n4hi,
|
||||
const char *name)
|
||||
{fail(name);}
|
||||
|
||||
TYPE ****create4d_offset(TYPE *****&array, int n1, int n2lo, int n2hi,
|
||||
int n3lo, int n3hi, int n4lo, int n4hi,
|
||||
const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
free a 4d array with indices 2,3, and 4 offset
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy4d_offset(TYPE ****array, int n2_offset, int n3_offset, int n4_offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[0][n2_offset][n3_offset][n4_offset]);
|
||||
sfree(&array[0][n2_offset][n3_offset]);
|
||||
sfree(&array[0][n2_offset]);
|
||||
sfree(array);
|
||||
}
|
||||
void destroy4d_offset(TYPE ****array,
|
||||
int n2_offset, int n3_offset, int n4_offset)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(&array[0][n2_offset][n3_offset][n4_offset]);
|
||||
sfree(&array[0][n2_offset][n3_offset]);
|
||||
sfree(&array[0][n2_offset]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
create a 5d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
|
||||
int n5, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4*n5;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3*n4;
|
||||
TYPE **level4 = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1*n2*n3;
|
||||
TYPE ***level3 = (TYPE ***) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ***)) * n1*n2;
|
||||
TYPE ****level2 = (TYPE ****) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ****)) * n1;
|
||||
array = (TYPE *****) smalloc(nbytes,name);
|
||||
|
||||
int i,j,k,l;
|
||||
bigint m1,m2,m3,m4,m5;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m2 = ((bigint) i) * n2;
|
||||
array[i] = &level2[m2];
|
||||
for (j = 0; j < n2; j++) {
|
||||
m1 = ((bigint) i) * n2 + j;
|
||||
m2 = ((bigint) i) * n2*n3 + ((bigint) j) * n3;
|
||||
level2[m1] = &level3[m2];
|
||||
for (k = 0; k < n3; k++) {
|
||||
m1 = ((bigint) i) * n2*n3 + ((bigint) j) * n3 + k;
|
||||
m2 = ((bigint) i) * n2*n3*n4 +
|
||||
((bigint) j) * n3*n4 + ((bigint) k) * n4;
|
||||
level3[m1] = &level4[m2];
|
||||
for (l = 0; l < n4; l++) {
|
||||
m1 = ((bigint) i) * n2*n3*n4 +
|
||||
((bigint) j) * n3*n4 + ((bigint) k) * n4 + l;
|
||||
level4[m1] = &data[n];
|
||||
n += n5;
|
||||
}
|
||||
TYPE *****create(TYPE *****&array, int n1, int n2, int n3, int n4,
|
||||
int n5, const char *name)
|
||||
{
|
||||
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4*n5;
|
||||
TYPE *data = (TYPE *) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3*n4;
|
||||
TYPE **level4 = (TYPE **) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE **)) * n1*n2*n3;
|
||||
TYPE ***level3 = (TYPE ***) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ***)) * n1*n2;
|
||||
TYPE ****level2 = (TYPE ****) smalloc(nbytes,name);
|
||||
nbytes = ((bigint) sizeof(TYPE ****)) * n1;
|
||||
array = (TYPE *****) smalloc(nbytes,name);
|
||||
|
||||
int i,j,k,l;
|
||||
bigint m1,m2,m3,m4,m5;
|
||||
bigint n = 0;
|
||||
for (i = 0; i < n1; i++) {
|
||||
m2 = ((bigint) i) * n2;
|
||||
array[i] = &level2[m2];
|
||||
for (j = 0; j < n2; j++) {
|
||||
m1 = ((bigint) i) * n2 + j;
|
||||
m2 = ((bigint) i) * n2*n3 + ((bigint) j) * n3;
|
||||
level2[m1] = &level3[m2];
|
||||
for (k = 0; k < n3; k++) {
|
||||
m1 = ((bigint) i) * n2*n3 + ((bigint) j) * n3 + k;
|
||||
m2 = ((bigint) i) * n2*n3*n4 +
|
||||
((bigint) j) * n3*n4 + ((bigint) k) * n4;
|
||||
level3[m1] = &level4[m2];
|
||||
for (l = 0; l < n4; l++) {
|
||||
m1 = ((bigint) i) * n2*n3*n4 +
|
||||
((bigint) j) * n3*n4 + ((bigint) k) * n4 + l;
|
||||
level4[m1] = &data[n];
|
||||
n += n5;
|
||||
}
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
TYPE ******create(TYPE ******&array, int n1, int n2, int n3, int n4,
|
||||
int n5, const char *name)
|
||||
{fail(name);}
|
||||
TYPE ******create(TYPE ******&array, int n1, int n2, int n3, int n4,
|
||||
int n5, const char *name)
|
||||
{fail(name); return NULL;}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
destroy a 5d array
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
void destroy(TYPE *****array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0][0][0]);
|
||||
sfree(array[0][0][0]);
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
void destroy(TYPE *****array)
|
||||
{
|
||||
if (array == NULL) return;
|
||||
sfree(array[0][0][0][0]);
|
||||
sfree(array[0][0][0]);
|
||||
sfree(array[0][0]);
|
||||
sfree(array[0]);
|
||||
sfree(array);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
memory usage of arrays, including pointers
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template <typename TYPE>
|
||||
bigint usage(TYPE *array, int n)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
bigint usage(TYPE *array, int n)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
bigint usage(TYPE **array, int n1, int n2)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
bigint usage(TYPE **array, int n1, int n2)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
bigint usage(TYPE ***array, int n1, int n2, int n3)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE **)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
bigint usage(TYPE ***array, int n1, int n2, int n3)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE **)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
|
||||
template <typename TYPE>
|
||||
bigint usage(TYPE ****array, int n1, int n2, int n3, int n4)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1*n2*n3;
|
||||
bytes += ((bigint) sizeof(TYPE **)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE ***)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
bigint usage(TYPE ****array, int n1, int n2, int n3, int n4)
|
||||
{
|
||||
bigint bytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
|
||||
bytes += ((bigint) sizeof(TYPE *)) * n1*n2*n3;
|
||||
bytes += ((bigint) sizeof(TYPE **)) * n1*n2;
|
||||
bytes += ((bigint) sizeof(TYPE ***)) * n1;
|
||||
return bytes;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue