How to allocate a large 3-dimensional array dynamically? - c++

Question

My computer RAM has 32GB of memory available. I want to define a 1500*1500*500 size array. How should I define a dynamic array?
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
#include <openacc.h>
#include <time.h>
#include <string.h>
#include <cuda_runtime_api.h>
void main(void) {
#define NX 1501
#define NY 1501
#define NZ 501
int i, j, k, l, m, dt, nstop;
double comp;
dt = 5;
nstop = 5
static double ex[NX][NY][NZ] = { 0. }, ey[NX][NY][NZ] = { 0. }, ez[NX][NY][NZ] = { 0. };
static double hx[NX][NY][NZ] = { 1. }, hy[NX][NY][NZ] = { 0. }, hz[NX][NY][NZ] = { 1. };
static double t, comp;
FILE *file;
file = fopen("point A hm=0.csv", "w"); /* Output data file name */
t = 0.;
for (l = 0; l < nstop; l++) {
for (i = 0; i < NX - 1; i++) {
for (j = 1; j < NY - 1; j++) {
for (k = 1; k < NZ - 1; k++) {
ex[i][j][k] = 2 * ey[i][j][k]
+ 3 * (hz[i][j][k] - hx[i][j - 1][k])
- 5 * (hy[i][j][k] - 2 * hz[i][j][k - 1]);
}
}
}
comp = ((double)(l + 1) / nstop) * 100.;
printf("Computation: %4.3f %% completed \r", comp);
fprintf(file, "%e, %e \n", t * 1e6, -ex[1200][950][20] + ex[1170][950][20]) / 2.);
t = t + dt;
}
fclose(file);
}

Answer 1

There must be an error in your problem statement:
the formula to compute ex[i][j][k] only depends on values from the other arrays with same i index for the first dimension. Since you only output the value of -ex[1200][950][20] + ex[1170][950][20]) / 2., you only need to compute the values for i=1200 and i=1170 and there is no need to allocate so much memory.
furthermore, the computed values in ex are the same for all values of l. No need to recompute at each iteration.
finally, given the initialization of the arrays, all values of ex for a first index other than 0 are null, so the output is trivial to compute: 0.0.
More seriously, if the initial values are small integers, the results seem to require only 32-bit integer arithmetics, which would reduce the memory requirements by 50%. Yet this would still exceed the maximum size for statically allocated objects on your system. You should allocate these 3D matrices dynamically this way:
double (*ex)[NY][NZ] = calloc(NX, sizeof(*ex));
Assuming your code is more complex than the sample posted, which incidentally contains a few typos that prevent compilation, here is what the modified code would look like:
#include <stdio.h>
#include <stdlib.h>
int main(void) {
#define NX 1501
#define NY 1501
#define NZ 501
int i, j, k, l, dt, nstop;
double comp;
dt = 5;
nstop = 5;
double (*ex)[NY][NZ] = calloc(NX, sizeof(*ex));
if (ex == NULL) { fprintf(stderr, "allocation failed for ex\n"); exit(1); }
double (*ey)[NY][NZ] = calloc(NX, sizeof(*ey));
if (ey == NULL) { fprintf(stderr, "allocation failed for ey\n"); exit(1); }
double (*ez)[NY][NZ] = calloc(NX, sizeof(*ez));
if (ez == NULL) { fprintf(stderr, "allocation failed for ez\n"); exit(1); }
double (*hx)[NY][NZ] = calloc(NX, sizeof(*hx));
if (hx == NULL) { fprintf(stderr, "allocation failed for hx\n"); exit(1); }
double (*hy)[NY][NZ] = calloc(NX, sizeof(*hy));
if (hy == NULL) { fprintf(stderr, "allocation failed for hy\n"); exit(1); }
double (*hz)[NY][NZ] = calloc(NX, sizeof(*hz));
if (hz == NULL) { fprintf(stderr, "allocation failed for hz\n"); exit(1); }
hx[0][0][0] = 1.;
hz[0][0][0] = 1.;
// probably many more initializations missing
double t;
FILE *file;
file = fopen("point A hm=0.csv", "w"); /* Output data file name */
if (file == NULL) { fprintf(stderr, "cannot create output file\n"); exit(1); }
t = 0.;
for (l = 0; l < nstop; l++) {
for (i = 0; i < NX - 1; i++) {
for (j = 1; j < NY - 1; j++) {
for (k = 1; k < NZ - 1; k++) {
ex[i][j][k] = 2 * ey[i][j][k]
+ 3 * (hz[i][j][k] - hx[i][j - 1][k])
- 5 * (hy[i][j][k] - 2 * hz[i][j][k - 1]);
}
}
}
comp = ((double)(l + 1) / nstop) * 100.;
printf("Computation: %4.3f %% completed \r", comp);
fprintf(file, "%e, %e \n", t * 1e6, (-ex[1200][950][20] + ex[1170][950][20]) / 2.);
t = t + dt;
}
fclose(file);
free(ex);
free(ey);
free(ez);
free(hx);
free(hy);
free(hz);
return 0;
}

Answer 2

There are several options. If you need to allocate the entire memory structure at once, your probably want to allocate for a pointer-to-pointer-to-array int[500] (int (**)[500]) rather than allocating for a pointer-to-pointer-to-pointer int (int ***)- though both are technically correct.
(note: I used int in the example, so just change the type of a to double to satisfy your needs)
To approach the allocation for a pointer-to-pointer-to-array int[500], start with your pointer and allocate 1500 pointers, e.g.
#define Z 500
#define X 1500
#define Y X
int main (void) {
int (**a)[Z] = NULL; /* pointer to pointer to array of int[500] */
if (!(a = malloc (X * sizeof *a))) { /* allocate X pointers to (*)[Z] */
perror ("malloc-X (**)[Z]");
return 1;
}
At this point you have 1500 pointers-to-array-of int[500]. You can loop of each allocated pointer above, allocating 1500 * sizeof (int[500) and assigning the starting address to each block allocated to one of the pointers, e.g.
for (int i = 0; i < X; i++) /* for each pointer */
if (!(a[i] = malloc (Y * sizeof **a))) { /* alloc Y * sizeof int[Z] */
perror ("malloc-YZ (*)[Z]");
return 1;
}
Now you can address each integer in your allocation as a[x][y][z]. Then to free the allocated memory, you just free() in the reverse order you allocated, e.g.
for (int i = 0; i < X; i++)
free (a[i]); /* free allocated blocks */
free (a); /* free pointers */
A short example that exercises this and writes a value to each index could be:
#include <stdio.h>
#include <stdlib.h>
#define Z 500
#define X 1500
#define Y X
int main (void) {
int (**a)[Z] = NULL; /* pointer to pointer to array of int[500] */
if (!(a = malloc (X * sizeof *a))) { /* allocate X pointers to (*)[Z] */
perror ("malloc-X (**)[Z]");
return 1;
}
puts ("pointers allocated");
for (int i = 0; i < X; i++) /* for each pointer */
if (!(a[i] = malloc (Y * sizeof **a))) { /* alloc Y * sizeof int[Z] */
perror ("malloc-YZ (*)[Z]");
return 1;
}
puts ("all allocated");
for (int i = 0; i < X; i++) /* set mem to prevent optimize out */
for (int j = 0; j < Y; j++)
for (int k = 0; k < Z; k++)
a[i][j][k] = i * j * k;
puts ("freeing memory");
for (int i = 0; i < X; i++)
free (a[i]); /* free allocated blocks */
free (a); /* free pointers */
}
Example Use/Output -- Timed Run
$ time ./bin/malloc_1500x1500x500
pointers allocated
all allocated
freeing memory
real 0m1.481s
user 0m0.649s
sys 0m0.832s
Memory Use/Error Check
That's 4.5G of memory allocated and used (warning: you will swap on 8G or less depending what else you have running if you run valgrind)
$ valgrind ./bin/malloc_1500x1500x500
==7750== Memcheck, a memory error detector
==7750== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==7750== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==7750== Command: ./bin/malloc_1500x1500x500
==7750==
pointers allocated
all allocated
freeing memory
==7750==
==7750== HEAP SUMMARY:
==7750== in use at exit: 0 bytes in 0 blocks
==7750== total heap usage: 1,502 allocs, 1,502 frees, 4,500,013,024 bytes allocated
==7750==
==7750== All heap blocks were freed -- no leaks are possible
==7750==
==7750== For counts of detected and suppressed errors, rerun with: -v
==7750== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Look things over and let me know if you have questions.

Answer 3

In C (as your code seems to be), you can for example use a triple pointer and malloc():
#define NX 1501
#define NY 1501
#define NZ 501
int*** p_a = malloc(sizeof(double**) * NX);
for (int i = 0; i < NX; i++)
{
p_a[i] = malloc(sizeof(double*) * NY)
for (int j = 0; j < NY; j++)
p_a[i][j] = malloc(sizeof(double) * NZ);
}
A more efficient way would be to use a single pointer and use the size of each dimension in call to malloc() at once:
double* p_a = malloc(sizeof(*p_a) * (NX * NY * NZ));
In C++, the most common and efficient way is to use a std::vector for dynamically allocating an array:
#define NX 1501
#define NY 1501
#define NZ 501
std::vector<std::vector<std::vector<double>>> a(NX, vector<vector<double>>(NY, vector<double>(NZ)));
Note that the size of a double object is on most modern platforms 8 Byte. Means, When you want to achieve what you want, you need at least 8 * 1500 * 1500 * 500 = 9000000000 Byte = about 8,3 Gbyte for each 3D array to allocate it. You define 6 of them, so 49,8 Gbyte are required to only allocate those arrays which is not provided by your systems as you said your system has 32 Gbyte available.