mallocNd.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

Include dependency graph for mallocNd.c:

Go to the source code of this file.

Functions
char *	BuildIndirectionTable ()
char *	mallocNd (unsigned int nDim, Dims, unsigned int sizeofelt)
char *	BuildIndirectionTable (unsigned nDim, Dims, char ***nextFreeTable, char **nextFreeArray, unsigned sizeofelt)
char *	malloc_2d (int n, int m, int sizeofelt)

Function Documentation

char* BuildIndirectionTable

(

)

char* BuildIndirectionTable	(	unsigned	nDim,
		Dims	,
		char ***	nextFreeTable,
		char **	nextFreeArray,
		unsigned	sizeofelt
	)

Definition at line 184 of file mallocNd.c.

{
  int i;
  char *ReturnValue, **table;
  
  if (nDim  == 1) { /* Base case, indirection table unneeded */
    ReturnValue =  *nextFreeArray;
    *nextFreeArray += sizeofelt * Dims[0];
  } else {  
    /* Allocate the 1'st level indirection table and fill it in 
    **  calling ourselves recursively for the others.
     */
    table =  *nextFreeTable;
    *nextFreeTable += Dims[0];
    for(i=0; i<Dims[0]; i++)
      {
    table[i] = BuildIndirectionTable( nDim-1, Dims+1, nextFreeTable, 
                     nextFreeArray, sizeofelt );
      }
    ReturnValue = (char *) table;
  }
  return ReturnValue;
}

char* malloc_2d	(	int	n,
		int	m,
		int	sizeofelt
	)

Definition at line 218 of file mallocNd.c.

{
  unsigned Dims[2];

  Dims[0] = n;
  Dims[1] = m;
  return mallocNd(2,Dims,sizeofelt);
}

char* mallocNd	(	unsigned int	nDim,
		Dims	,
		unsigned int	sizeofelt
	)

Definition at line 125 of file mallocNd.c.

{
  int i;
  char *ptr, *tableBase, *arrayBase, *nextFreeArray, *nextFreeTable;
  unsigned int arrayBytesNeeded, tableBytesNeeded, dimProduct, slop;
  
  /* Count up the space needed for the indirection tables.
   **  It's sizeof(pointer) * Dim[0] * ( 1 + Dim[1] * ( 1 + Dim[2] ... ))
   */
  tableBytesNeeded = 0;
  dimProduct  = 1;
  for(i=0; i<nDim-1;  i++)
    {
      dimProduct *= Dims[i];
      tableBytesNeeded += dimProduct*sizeof(char *);
    }
  
  /* Add in extra space to force alignment of the array */
  slop = (tableBytesNeeded % sizeofelt);
  if (slop != 0) 
    slop = sizeofelt - slop;

  /*  Add in the space for the array itself */
  dimProduct *= Dims[i];
  arrayBytesNeeded = dimProduct*sizeofelt;
  
  /* Get the memory for the whole thing */
  ptr = malloc( tableBytesNeeded + slop + arrayBytesNeeded );
  if (ptr == NULL) return (char *) NULL;
  
  /* Set up the base address of the actual array and the indirection table */
  tableBase = ptr;
  arrayBase = ptr + slop + tableBytesNeeded;
  
  /* Set up the next free pointers for the table space and the array space */
  nextFreeTable = tableBase;
  nextFreeArray = arrayBase;
  
  /* Build the indirection tables recursively */
  (void) BuildIndirectionTable( nDim, Dims,  (char ***)&nextFreeTable, 
                   &nextFreeArray, sizeofelt );

  /* Do a sanity check to be sure we haven't run off the end of the allocated
  ** memory.  Not strictly needed but here for robustness and debugging.
  */
  if (nextFreeTable != arrayBase - slop  ||
      nextFreeArray != ptr + tableBytesNeeded + slop + arrayBytesNeeded)
    {
      fprintf( stderr, "Error in mallocNd!  Memory overwrite." );
      abort();
    }
  return(char *) tableBase;
}