MPP-arralloc.tar

arralloc/000075501040010007640000000000001127156124700124605ustar00dshepcc00005600000443arralloc/arralloc.h000064001040010007640000000000540774247457400144410ustar00dshepcc00005600000443void *arralloc(size_t size, int ndim, ...);
arralloc/Makefile000064001040010007640000000005621127156226100141140ustar00dshepcc00005600000443MF=	Makefile

CC=	pgcc
CFLAGS=

LFLAGS= $(CFLAGS)

EXE=	arralloctest

INC= \
	arralloc.h

SRC= \
	arralloctest.c \
	arralloc.c \

#
# No need to edit below this line
#

.SUFFIXES:
.SUFFIXES: .c .o

OBJ=	$(SRC:.c=.o)

.c.o:
	$(CC) $(CFLAGS) -c $<

all:	$(EXE)

$(OBJ):	$(INC)

$(EXE):	$(OBJ)
	$(CC) $(LFLAGS) -o $@ $(OBJ)

$(OBJ):	$(MF)

clean:
	rm -f $(EXE) $(OBJ) core
arralloc/arralloctest.c000064001040010007640000000033741204127154100153150ustar00dshepcc00005600000443#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h> 

#include "arralloc.h"

void printlinearbuffer(float *x, int n);
void print3Darray(float ***x, int ni, int nj, int nk);

int main(void)
{
  int nx, ny, nz;
  int i, j, k;

  float ***array;

  nx = 2;
  ny = 4;
  nz = 3;

  array = arralloc(sizeof(float), 3, nx, ny, nz);

  for (i=0; i < nx; i++)
    {
      for (j=0; j < ny; j++)
	{
	  for (k=0; k < nz; k++)
	    {
	      array[i][j][k] = k + j*nz + i*nz*ny;
	    }
	}
    }

  printf("array[%d][%d][%d] = %f\n", nx/2,ny/2,nz/2, array[nx/2][ny/2][nz/2]);

  /*
   *  The following call is correct - pass address of first data element
   */

  printf("\nArray passed correctly to a function expecting a linear buffer\n\n");

  printlinearbuffer(&(array[0][0][0]), nx*ny*nz);

  /*
   *  The following call is INCORRECT - you should NOT pass the array itself
   */

  printf("\nArray passed INCORRECTLY to a function expecting a linear buffer\n\n");

  printlinearbuffer((float *) array, nx*ny*nz);

  /*
   *  The following call is correct - can pass address of array provided that
   *  the function being called expects a 3D array and not a linear buffer
   */

  printf("\nArray passed correctly to a function expecting a 3D array\n\n");

  print3Darray(array, nx, ny, nz);

  /*
   *  Entire multidimensional array is deallocated with a single free
   */

  free(array);
}
      
void printlinearbuffer(float *x, int n)
{
  int i;

  for (i=0; i < n; i++)
    {
      printf("x[%d] = %f\n", i, x[i]);
    }
}

void print3Darray(float ***x, int ni, int nj, int nk)
{
  int i, j, k;

  for (i=0; i < ni; i++)
    {
    for (j=0; j < nj; j++)
      {
      for (k=0; k < nk; k++)
        {
  	  printf("x[%d][%d][%d] = %f\n", i, j, k, x[i][j][k]);
        }
      }
    }
}
arralloc/README.txt000064001040010007640000000017661110602760600141550ustar00dshepcc00005600000443Compile using "make" and run the executable "arralloctest".

Note that the second call to printlinearbuffer is INCORRECT - it is just
there to show what you should NOT do! It runs, but produces strange
results. The first call is the correct one, which is what you should do
when calling an MPI routine or the IO functions.

There is also an example of how to pass the array to a routine that does
expect a multidimensional array, where you also pass the sizes of all
the dimensions. This is what you should do when calling your own
routines.

Note that if you used the more straightforward approach of using many
separate mallocs then you could still pass the array to your own
function which expected a multidimensional array. However, you would NOT
be able to pass the data to a function expecting a single contiguous
block of memory (eg an MPI routine) as your data would be scattered
around in memory with no defined pattern. Using arralloc gets round this
problem as all the data is stored in a single block.
arralloc/arralloc.c000064001040010007640000000106011072152152600144100ustar00dshepcc00005600000443/******************************************************************************
 * Alloc	Interface functions to dynamic store allocators.	      *
 * arralloc()	Allocate rectangular dope-vector (ie using pointers) array    *
 ******************************************************************************/

/*========================== Library include files ===========================*/
#include <stddef.h>
#include <stdarg.h>
#include <malloc.h>
/*========================== Library declarations ============================*/
/* char	*calloc(); */
/* char	*malloc(); */
/*========================== External function declarations ==================*/
#ifdef	DEBUG
int	malloc_verify();
int	malloc_debug();
#endif
/******************************************************************************
 *  ~arralloc.  Allocate a psuedo array of any dimensionality and type with   *
 *  specified size for each dimension.  Each dimension is	 	      *
 *  an array of pointers, and the actual data is laid out in standard 'c'     *
 *  fashion ie last index varies most rapidly.  All storage is got in one     *
 *  block, so to free whole array, just free the pointer array.               *
 *  array = (double***) arralloc(sizeof(double), 3, 10, 12, 5);		      *
 ******************************************************************************/

/* ALIGN returns the next b byte aligned address after a */
#define ALIGN(a,b)	(int*)( (((long)(a) + (b) - 1)/(b))*(b) )

/* If on an I860 align arrays to cache line boundaries */
#ifdef I860
#define MIN_ALIGN 32
#else
#define MIN_ALIGN 1
#endif

/*----------------------------------------------------------------------*/


void 	subarray(align_size, size, ndim, prdim, pp, qq, dimp, index)
size_t  align_size;	/* size of object to align the data on */
size_t  size;		/* actual size of objects in the array */
int	ndim, prdim;	/* ndim- number of dim left to do */
			/* prdim - no of pointers in previous iteration */
void	***pp, **qq;	/* pp - pointer to previous level of the array */
			/* qq - pointer to start of this level */
int *dimp, index;
{
   int	*dd = ALIGN(qq,align_size);	/*aligned pointer only used in last recursion*/
   int	**dpp = (int**)pp;
   int i,	dim = dimp[index];

   if(ndim > 0)		/* General case - set up pointers to pointers  */
   {
      for( i = 0; i < prdim; i++)
	 pp[i] = qq + i*dim;	/* previous level points to us */

      subarray(align_size, size, ndim-1, prdim*dim,
				(void***)qq,	/* my level filled in next */
				qq+prdim*dim,	/* next level starts later */
				dimp, (index+1) );
   }
   else			/* Last recursion - set up pointers to data   */
      for( i = 0; i < prdim; i++)
	 dpp[i] = dd + (i*dim)*size/sizeof(int);
}
            


/*-----------------------------------------------------------------------*/

/* 
 * if REFS is defined the va macros are dummied out. This is because the
 * GreenHills va_arg macro will not get past the cref utility.
 * This way the call tree can still be constructed. Do NOT under
 * any circumstance define REFS when compiling the code.
 */

#if REFS
   #undef va_start
   #undef va_arg
   #undef va_end
   #undef va_list
   #define va_list int
   #define va_start( A , B) ( A = (int) B)
   #define va_end( A ) ( A = 0 )
   #define va_arg( A , T ) ( A = (T) 0)
#endif

void *arralloc(size_t size, int ndim, ...)
{
   va_list	ap;
   void		**p, **start;
   int		idim;
   long		n_ptr = 0, n_data = 1;
   int 		*dimp;
   size_t	align_size;

   va_start(ap, ndim);

   if( size % sizeof(int) != 0 )  /* Code only works for 'word' objects */
      return 0;
   /* we want to align on both size and MIN_ALIGN */
   if( size > MIN_ALIGN )
   {
   	align_size = size;
   }
   else
   {
   	align_size = MIN_ALIGN;
   }
   while( (align_size % size) || (align_size % MIN_ALIGN) )
   {
   	align_size++;
   }
   /*
    * Cycle over dims,  accumulate # pointers & data items.
    */
   if ( NULL == (dimp=(int *)malloc( ndim * sizeof(int) )))
	return 0;

   for(idim = 0; idim < ndim; idim++)
   {
      dimp[idim] = va_arg(ap, int);
      n_data *= dimp[idim];
      if( idim < ndim-1 )
	 n_ptr  += n_data;
   }
   va_end(ap);   


   /*
    *  Allocate space  for pointers and data.
    */
   if( (start = (void**)malloc(
		(size_t)((n_data*size)+align_size+(n_ptr*sizeof(void**))))) == 0)
      return 0;
   /*
    * Set up pointers to form dope-vector array.
    */
   subarray(align_size, size, ndim-1, 1, &p, start, dimp, 0);
   free( dimp );

   return (void*)p;
}


N(a,b)	(int*)( (((long)(a) + (b) - 1)/(b))*(b) )

/* If on an I860 align arrays to cache line boundaries */
#ifdef I860
#define