This is a simple example on how to use dynamically allocated arrays useful for CFD applications.
Adapt 'Makefile' to your system and run:
make
./main
main |
# 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 |
# 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; | |
} | |
} | |
} |
# ifndef INIT_H | |
# define INIT_H | |
int allocate(); | |
void deallocate(); | |
void fill(); | |
# endif |
# 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(); | |
} |
# 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))))))))))))))))) |
# 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))))))))))))))))) |
#!/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))) |
CC = g++ | |
#CcFLAGS = -g | |
CcFLAGS = -O3 | |
main: main.cpp init.cpp | |
$(CC) -o $@ $^ $(CCFLAGS) | |
clean: | |
rm main | |
.PHONY: clean |