3 Dimensional array memory allocation

Question

I have a code with a memory allocation for 3D array called "matrix" which I generally index for the x,y,z direction as matrix[i][j][k] where i,j and k are the index in x, y and z direction respectively. The allocation procedure that has been followed in the code is as follows ( lr is just a typedef for double )

lr ***lr_3D_matrix(int m, int n, int o)/**  \brief create a 3D matrix with size [m, n,o] of type lr*/
{
    lr ***matrix;
    int i, j;
    matrix =  malloc(m * sizeof(lr **));    //allocate first dimension
    matrix[0] =  malloc(m * n * sizeof(lr *));  //allocate continous memory block for all elements
    matrix[0][0] = malloc(m * n * o * sizeof(lr))
    for(j = 1; j < n; j++)  //fill first row
    {
        matrix[0][j] = matrix[0][j - 1] + o;    //pointer to matrix[0][j][0], thus first element of matrix[0][j][o]
    }

    for(i = 1; i < m; ++i)
    {
        matrix[i] = matrix[i - 1] + n;  //pointer to position of  to matrix[i][0]
        matrix[i][0] = matrix[i - 1][n - 1] + o;    //pointer to  matrix[i][j][0];
        for(j = 1; j < n; ++j)
        {
                    matrix[i][j] = matrix[i][j - 1] + o;
        }
    }
    return matrix;
}

Now, I want to port this code in a way that this matrix can be accessed in a same way using Shared Memory IPC with another code. So if i declare the memory as

ShmID = shmget(ShmKEY, m*n*o*sizeof(lr), IPC_CREAT | 0666);

then how should I attach this block of memory to a tripple pointer such that the memory access remains same ?

example for attaching this as a single pointer I can write

matrix = (lr *) shmat(ShmID, NULL, 0);

Also I am bit struggling with the for loops in the original code and what they are actually doing ?

Edit: ShmKEY is just an identifier known apriori.

Answer 1

In a slight note of pedantry, an array is a single allocation, so what you have can't be a 3D array. It's much more like a tree, designed to emulate a 3-dimensional array.

For example, you have your root node:

matrix =  malloc(m * sizeof(lr **));    //allocate first dimension

Then you have some leaf nodes:

matrix[0] =  malloc(m * n * sizeof(lr *));

Then you have a block of memory that each of the leaf nodes points into:

matrix[0][0] = malloc(m * n * o * sizeof(lr)); // note: you were missing a semicolon here

You really only need the last allocation. One allocation is better than many, when you're talking about one array. Here's an example of allocating a 3-dimensional array, if you can call it that...

typedef lr lr_[o];
typedef lr_ lr__[n];
lr__ *matrix = malloc(m * sizeof matrix[0]);
free(matrix); /* you should probably error check and use your memory first,
               * but we're done with this example now, and when we're done
               * with something `malloc`'d we `free` it.
               */

*Note: As pointed out below, you can lose the typedefs and use the more complex (though not by far), condensed notation.

---

ShmID = shmget(ShmKEY, m*n*o*sizeof(lr), IPC_CREAT | 0666);

then how should I attach this block of memory to a tripple pointer such that the memory access remains same ?

matrix = (lr *) shmat(ShmID, NULL, 0);

This last line of code is essentially equivalent to matrix[0][0] = malloc(m * n * o * sizeof(lr)), from your question... so I think you should consider changing that line to:

matrix[0][0] = shmat(ShmID, NULL, 0);

---

However, if you wanted to use a single allocation like I have done, then you could write:

ShmID = shmget(ShmKEY, m * n * o * sizeof (lr));
lr__ *matrix = shmat(ShmID, NULL, 0);
shmdt(matrix); // as I understand, `shmdt` is roughly analogous to `free`

Then you won't need the loops to construct your tree. ;)