Dynamic Arrays in C++ for CFD Applications

.gitignore

main

README.md

Dynamic Arrays in C++ for CFD Applications

This is a simple example on how to use dynamically allocated arrays useful for CFD applications.

Compilation

Adapt 'Makefile' to your system and run:

make

Running

./main

globals.hpp

# ifndef GLOBALS_H
# define GLOBALS_H

// array element access macros
# define I1(d1,i1) (0 + (i1-0))
# define I2(d1,d2,i1,i2) (0 + ((i2-0) + (d2)*(i1-0)))
# define I3(d1,d2,d3,i1,i2,i3) (0 + ((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))
# define I4(d1,d2,d3,d4,i1,i2,i3,i4) (0 + ((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))
# define I5(d1,d2,d3,d4,d5,i1,i2,i3,i4,i5) (0 + ((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))

# define NX 4 // N cells in x-direction
# define NY 6 // N cells in y-direction
# define NV 4 // number of state variables

# define DENS 0
# define MOMX 1
# define MOMY 2
# define ENER 3

// global arrays
extern double *states;

# endif

init.cpp

# include "globals.hpp"
# include <cstdlib>

double *states = NULL;

int allocate() {
    states = (double*) calloc(NX*NY*NV, sizeof(double));

    if (states == NULL)
        return -1; // error in allocating memory

    return 0; // ok
}

void deallocate() {
    free(states);
}

void fill() {
    for (int i = 0; i < NX; i++) {
        for (int j = 0; j < NY; j++) {
            states[I3(NX,NY,NV,i,j,DENS)] = 10*i + j;
            states[I3(NX,NY,NV,i,j,MOMX)] = 0.0;
            states[I3(NX,NY,NV,i,j,MOMY)] = 0.0;
            states[I3(NX,NY,NV,i,j,ENER)] = 1.0;
        }
    }
}

init.hpp

# ifndef INIT_H
# define INIT_H

int allocate();
void deallocate();
void fill();
# endif

main.cpp

# include "globals.hpp"
# include <iostream>
# include <cstdlib>

# include "init.hpp"

int main(int argc, char* argv[]) {
    int errno;

    errno = allocate(); 

    if (errno == 0) {
        fill();
    } else {
        std::cerr << "Error in memory allocation!" << std::endl;
    }

    std::cout << "i" << "\t" << "j" << "\t" << "dens" << std::endl;
    std::cout << "--------------------" << std::endl;
    for (int i = 0; i < NX; i++) {
        for (int j = 0; j < NY; j++) {
            std::cout << i << "\t" << j << "\t" << states[I3(NX,NY,NV,i,j,DENS)] << std::endl;
        }
    }

    deallocate();
}

major-col.txt

# define I1(d1,i1) (1 + (i1-1))
# define I2(d1,d2,i1,i2) (1 + ((i1-1) + (d1)*(i2-1)))
# define I3(d1,d2,d3,i1,i2,i3) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*(i3-1))))
# define I4(d1,d2,d3,d4,i1,i2,i3,i4) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*(i4-1)))))
# define I5(d1,d2,d3,d4,d5,i1,i2,i3,i4,i5) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*(i5-1))))))
# define I6(d1,d2,d3,d4,d5,d6,i1,i2,i3,i4,i5,i6) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*(i6-1)))))))
# define I7(d1,d2,d3,d4,d5,d6,d7,i1,i2,i3,i4,i5,i6,i7) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*(i7-1))))))))
# define I8(d1,d2,d3,d4,d5,d6,d7,d8,i1,i2,i3,i4,i5,i6,i7,i8) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*(i8-1)))))))))
# define I9(d1,d2,d3,d4,d5,d6,d7,d8,d9,i1,i2,i3,i4,i5,i6,i7,i8,i9) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*(i9-1))))))))))
# define I10(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*(i10-1)))))))))))
# define I11(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*(i11-1))))))))))))
# define I12(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*((i11-1) + (d11)*(i12-1)))))))))))))
# define I13(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*((i11-1) + (d11)*((i12-1) + (d12)*(i13-1))))))))))))))
# define I14(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*((i11-1) + (d11)*((i12-1) + (d12)*((i13-1) + (d13)*(i14-1)))))))))))))))
# define I15(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*((i11-1) + (d11)*((i12-1) + (d12)*((i13-1) + (d13)*((i14-1) + (d14)*(i15-1))))))))))))))))
# define I16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16) (1 + ((i1-1) + (d1)*((i2-1) + (d2)*((i3-1) + (d3)*((i4-1) + (d4)*((i5-1) + (d5)*((i6-1) + (d6)*((i7-1) + (d7)*((i8-1) + (d8)*((i9-1) + (d9)*((i10-1) + (d10)*((i11-1) + (d11)*((i12-1) + (d12)*((i13-1) + (d13)*((i14-1) + (d14)*((i15-1) + (d15)*(i16-1)))))))))))))))))

major-row.txt

# define I1(d1,i1) (0 + (i1-0))
# define I2(d1,d2,i1,i2) (0 + ((i2-0) + (d2)*(i1-0)))
# define I3(d1,d2,d3,i1,i2,i3) (0 + ((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))
# define I4(d1,d2,d3,d4,i1,i2,i3,i4) (0 + ((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))
# define I5(d1,d2,d3,d4,d5,i1,i2,i3,i4,i5) (0 + ((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))
# define I6(d1,d2,d3,d4,d5,d6,i1,i2,i3,i4,i5,i6) (0 + ((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))
# define I7(d1,d2,d3,d4,d5,d6,d7,i1,i2,i3,i4,i5,i6,i7) (0 + ((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))))
# define I8(d1,d2,d3,d4,d5,d6,d7,d8,i1,i2,i3,i4,i5,i6,i7,i8) (0 + ((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))))
# define I9(d1,d2,d3,d4,d5,d6,d7,d8,d9,i1,i2,i3,i4,i5,i6,i7,i8,i9) (0 + ((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))))))
# define I10(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10) (0 + ((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))))))
# define I11(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11) (0 + ((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))))))))
# define I12(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12) (0 + ((i12-0) + (d12)*((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))))))))
# define I13(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13) (0 + ((i13-0) + (d13)*((i12-0) + (d12)*((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))))))))))
# define I14(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14) (0 + ((i14-0) + (d14)*((i13-0) + (d13)*((i12-0) + (d12)*((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))))))))))
# define I15(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15) (0 + ((i15-0) + (d15)*((i14-0) + (d14)*((i13-0) + (d13)*((i12-0) + (d12)*((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0))))))))))))))))
# define I16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16) (0 + ((i16-0) + (d16)*((i15-0) + (d15)*((i14-0) + (d14)*((i13-0) + (d13)*((i12-0) + (d12)*((i11-0) + (d11)*((i10-0) + (d10)*((i9-0) + (d9)*((i8-0) + (d8)*((i7-0) + (d7)*((i6-0) + (d6)*((i5-0) + (d5)*((i4-0) + (d4)*((i3-0) + (d3)*((i2-0) + (d2)*(i1-0)))))))))))))))))

major.py

#!/usr/bin/env python

from __future__ import print_function
import sys

def head(xs):
    return xs[ 0]

def last(xs):
    return xs[-1]

def tail(xs):
    return xs[ 1:]

def init(xs):
    return xs[:-1]

usage = \
"""# Usage #

> ./major [row|col] start ranks

# Examples #

* print macro for a row-major rank-4 array 0-indexed

   > ./major row 0 4

* print macro for a column-major rank-12 array 1-indexed

   > ./major col 1 12

* print multiple macros for zero-indexed row-major arrays and send to file

   > seq 1 9 | xargs -n1 ./major.py row 0 > rowmajor.h
"""

try:
    major = sys.argv[1]
    start = int(sys.argv[2])
    ranks = int(sys.argv[3])
except:
    print(usage)
    sys.exit(1)

def major_prototype(ssplit,lsplit,start):
    """
    [arguments]
        * ssplit: scalar split function: head, last
        * lsplit: list split function: init, tail
    [return]
        * function generating row/colum major offset calculation
    """

    def prototype(ns,xs):
        """
        [arguments]
            * ns: array with number of elements in each direction
            * xs: array with index in each direction
        [return]
            * string containing offset calculation for row/column major
        """
        if len(xs) == 1:
            return '{1}-{0}'.format(start,xs[0])
        return '({1}-{0}) + ({2})*({3})'.format(start,ssplit(xs),ssplit(ns),prototype(lsplit(ns),lsplit(xs)))

    return prototype

if major.lower() in 'row':
    fun = major_prototype(last,init,start)
elif major.lower() in 'column':
    fun = major_prototype(head,tail,start)
else:
    raise KeyError('Unknown major: {0}'.format(major))

index = ['i{0}'.format(i) for i in range(1,ranks+1)]
ndims = ['d{0}'.format(i) for i in range(1,ranks+1)]

signature = ','.join(ndims) + ',' + ','.join(index)

print('# define I{1}({2}) ({0} + ({3}))'.format(start,ranks,signature,fun(ndims,index)))

Makefile

CC      = g++
#CcFLAGS = -g
CcFLAGS = -O3

main: main.cpp init.cpp
	$(CC) -o $@ $^ $(CCFLAGS)

clean:
	rm main

.PHONY: clean