al_proto.h File Reference

ArrayLib function prototypes header file. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	AL_Init (int *, char ***)
int	AL_Finalize ()
int	AL_Initialized ()
int	AL_Sz_init (MPI_Comm, int *)
int	AL_Free (int)
int	AL_Sz_free (int)
int	AL_Valid_ptr (int)
int	AL_Set_comm (MPI_Comm, int)
int	AL_Set_dimensions (int, int)
int	AL_Set_type (AL_Datatype, int, int)
int	AL_Set_global_dim (int *, int)
int	AL_Set_local_dim (int *, int)
int	AL_Set_parallel_dim (int *, int)
int	AL_Set_periodic_dim (int *, int)
int	AL_Set_staggered_dim (int *, int)
int	AL_Set_ghosts (int *, int)
int	AL_Get_size (int, int *)
int	AL_Get_comm (int, MPI_Comm *)
int	AL_Get_cart_comm (int, MPI_Comm *)
int	AL_Get_dimensions (int, int *)
int	AL_Get_type (int, AL_Datatype *)
int	AL_Get_buffsize (int, int *)
int	AL_Get_global_dim (int, int *)
int	AL_Get_local_dim (int, int *)
int	AL_Get_local_dim_gp (int, int *)
int	AL_Get_parallel_dim (int, int *)
int	AL_Get_periodic_dim (int, int *)
int	AL_Get_staggered_dim (int, int *)
int	AL_Get_ghosts (int, int *)
int	AL_Get_offsets (int, int *)
int	AL_Get_lbounds (int, int *, int *, int *, int)
int	AL_Get_gbounds (int, int *, int *, int *, int)
int	AL_Get_bounds (int, int *, int *, int *, int)
int	AL_Is_boundary (int, int *, int *)
int	AL_Get_stride (int, int *)
int	AL_Decompose (int, int *, int)
int	AL_Type_create_subarray (int, int *, int *, int *, int, MPI_Datatype, MPI_Datatype *)
void *	AL_Allocate_array (int)
int	AL_Exchange (void *, int)
int	AL_Exchange_dim (char *, int *, int)
int	AL_Exchange_periods (void *vbuf, int *periods, int sz_ptr)
int	AL_File_open (char *, int)
long long	AL_Get_offset (int)
int	AL_Set_offset (int, long long)
int	AL_Write_header (void *, int, AL_Datatype, int)
int	AL_File_close (int)
int	AL_Write_common (void *, int, AL_Datatype, int)
int	AL_Read_common (void *, int, AL_Datatype, int)
int	AL_Write_array (void *, int, int)
int	AL_Read_array (void *, int, int)
int	AL_Write_array_begin (void *, int, int *, int *, int)
int	AL_Write_array_end (void *, int)
int	AL_Init_stack_ ()
int	AL_Allocate_sz_ ()
int	AL_Deallocate_sz_ (int)
int	AL_Auto_Decomp_ (int, int, int *, int *)
int	AL_Sort_ (int, int *, int *)

Detailed Description

ArrayLib function prototypes header file.

Contains the function prototypes used in the ArrayLib routines.

Author

A. Malagoli (University of Chicago)

A. Mignone (migno.nosp@m.ne@p.nosp@m.h.uni.nosp@m.to.i.nosp@m.t)

G. Muscianisi (g.mus.nosp@m.cian.nosp@m.isi@c.nosp@m.inec.nosp@m.a.it)

Date

Aug 16, 2012

Definition in file al_proto.h.

Function Documentation

void* AL_Allocate_array

(

int

sz_ptr

)

Allocate the local buffer for a distributed array

Parameters

[in]

sz_ptr

pointer to SZ array (integer)

Definition at line 25 of file al_alloc.c.

{
  char *a;
  int myrank, nproc;
  int size;
  long int buffsize;
  MPI_Comm comm;
  SZ *s;



  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Allocate_array: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc  = s->size;
  comm   = s->comm;

  buffsize = s->buffsize;

  MPI_Type_size(s->type, &size);

  if( !(a = (char *)AL_CALLOC_((int) buffsize,size)) ){
    printf("[%d] AL_Allocate_array: allocation error\n",myrank);
    return 0;
  }

  /* DIAGNOSTICS */
#ifdef DEBUG
    printf("AL_Allocate_array: allocated %ld bytes\n",buffsize*size);
#endif

  return (void *)a;
}

int AL_Allocate_sz_

(

)

Return an integer pointer to an SZ stack entry.

Definition at line 58 of file al_szptr_.c.

{
  register int i;
  int sz_ptr; /* The returned pointer to the SZ array */

  sz_ptr = -1;

  /*
    First, search the stack for the first 
     available pointer 
  */
  for( i=0; i<AL_MAX_ARRAYS; i++){
    if( stack_ptr[i] == AL_STACK_FREE ){
      sz_ptr = i;
      stack_ptr[i] = AL_STACK_USED;
      break;
    }
  }

  /* 
     If the allocation did not fail, then proceed to
     allocate a SZ structure 
  */
  if( sz_ptr != -1 ){
    if( !(sz_stack[i] = (SZ *)malloc(sizeof(SZ))) ){
      printf("AL_Allocate_sz_: Failed to allocate SZ\n");
    }
  }

  /*
    If we were successful, then set sz.compiled to AL_FALSE,
    indicating the need for intialization.
  */
  sz_stack[sz_ptr]->compiled = AL_FALSE;

  return sz_ptr;

} 

Here is the caller graph for this function:

int AL_Auto_Decomp_	(	int	nproc,
		int	npdim,
		int *	ldims,
		int *	gdims
	)

Find a "maximally cubic" processors distribution.

Parameters

[in]	nproc	number of processors
[in]	npdim	number of parallel dimensions
[out]	ldims	processor decomposition along directions
[in]	gdims	global array sizes

Definition at line 19 of file al_decomp_.c.

{
  /*
    1D case. We do not need to do anything, really
  */
  if( npdim == 1 ) {
    ldims[0] = nproc;
    return (int) AL_SUCCESS;
  }

  /*
    2D case. Slightly more complicated
  */
  if( npdim == 2 ) {
    if( AL_Decomp_2d_(nproc, npdim, ldims, gdims) == AL_FAILURE) {
      return (int) AL_FAILURE;    
    } else {
      return (int) AL_SUCCESS;
    }
  }

  /*
    3D case. Even more complicated
  */
  if( npdim == 3 ) {
    if( AL_Decomp_3d_(nproc, npdim, ldims, gdims) == AL_FAILURE) {
      return (int) AL_FAILURE;    
    } else {
      return (int) AL_SUCCESS;
    }
  }


return 0;  
}  

Here is the call graph for this function:

Here is the caller graph for this function:

int AL_Deallocate_sz_

(

int

sz_ptr

)

Deallocate an integer pointer to an SZ stack entry.

Parameters

[in]

sz_ptr

Integer pointer to an entry in the SZ stack

Definition at line 102 of file al_szptr_.c.

{
  register int i;
  int ndim;
  SZ *s;

  if(sz_ptr<0) return AL_SUCCESS;
  if(stack_ptr[sz_ptr] == AL_STACK_FREE) return AL_SUCCESS;
  
  s = sz_stack[sz_ptr];
  ndim = s->ndim;

  /* 
     Free the MPI data types
  */
  if( s->compiled == AL_TRUE ){
    for( i=0; i<ndim; i++){
      MPI_Type_free(&(s->strided[i]));
      MPI_Type_free(&(s->type_lr[i]));
      MPI_Type_free(&(s->type_rl[i]));
      MPI_Comm_free(&(s->oned_comm[i]));
    }

    MPI_Type_free(&(s->gsubarr));
    MPI_Type_free(&(s->lsubarr));
    MPI_Comm_free(&(s->cart_comm));
  }

  if( (s->begs != NULL) ) free(s->begs);

  /*
    Begin by dellocating the SZ structure 
  */
  free(sz_stack[sz_ptr]); 
  
  /*
    Now we can reset the integer pointer
  */
  stack_ptr[sz_ptr] = AL_STACK_FREE;
  return (int) AL_SUCCESS;
} 

Here is the caller graph for this function:

int AL_Decompose	(	int	sz_ptr,
		int *	procs,
		int	mode
	)

Create a distributed array descriptor and compile it

Parameters

[in]	sz_ptr	integer pointer to the distributed array descriptor
[in,out]	procs	array with the processor decomposition
[in]	mode	available value: AL_AUTO_DECOMP (internal decomposition) [Only for powers of two dimensions]; AL_MPI_DECOMP (MPI decomposition); AL_USER_DECOMP (user defined)

Bug fixed on Aug 26, 2012: When the global view of the file for a staggered variable is computed, the gdims[nd] has to be computed and then passed to the function AL_Type_create_subarray.

Since gdims[nd]=s->arrdim[nd], and in s->arrdim[nd] is taking into account that the variable is staggered, we comment the line "gdims[istag]++;" because it is no more needed.

Bug fixed on Aug 26, 2012: The following "if" has been modified:

OLD version: if (s->beg[istag] == s->bg[istag]) { ldims[istag]++; }else{ starts[istag]++; }

NEW version: if (s->beg[istag] == s->bg[istag]) { }else{ starts[istag]++; ldims[istag]–; }

• "ldims[istag]++;" has been cancelled from the firt part of the if for the same motivation explaned before;
• "ldims[istag]--;" has been added in the second part of the if because in PLUTO the index of the staggered variables start from -1, while in the ArrayLib they start from 0.

Bugs fixed on Aug 26, 2012: The following if has been modified:

OLD version: if (s->beg[istag] == s->bg[istag]) { ldims[istag]++; starts[istag]–; }

NEW version: if (s->beg[istag] == s->bg[istag]) { }else{ ldims[istag]–; starts[istag]++; }

• "ldims[istag]++;" has been cancelled from the firt part of the if because when the local subarray for the MPI_Set_write_all for a staggered variable is computed, the ldims[nd] has to be computed and then passed to the function AL_Type_create_subarray. Since ldims[nd]=s->larrdim[nd], and in s->larrdim[nd] is taking into account that the variable is staggered, we remouved the line "ldims[istag]++;" because it is no more needed;
• "starts[istag]--;" has been cancelled from the first part of the if because in PLUTO the indexes for the staggered variables start locally from -1, while in ArrayLib they start from 0;
• the "else" has been added to take into account the motivation explaned in the point before.

Definition at line 39 of file al_decompose.c.

{
  int myrank, nproc;
  SZ *s;

  register int i, nd, nb;

  int ndim;
  int gdims[AL_MAX_DIM], ldims[AL_MAX_DIM], starts[AL_MAX_DIM];
  int count[AL_MAX_DIM], blocklen[AL_MAX_DIM], periods[AL_MAX_DIM];
  int reord, nleft, nright;
  int stagpt, type_size;
  int stride[AL_MAX_DIM];
  MPI_Datatype itype,ivector;
  MPI_Comm comm, cart_comm;

  int Find_decomp = AL_TRUE; /* By default, we use the internal decomposition */

  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Decompose: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc = s->size;

  ndim = s->ndim;

  /*
    Find if we need to find our own decomposition
  */

  if( mode != AL_USER_DECOMP && mode != AL_AUTO_DECOMP && mode != AL_MPI_DECOMP ) {
    printf("AL_Decompose: wrong mode. Using default AL_MPI_DECOMP\n");
    mode = AL_MPI_DECOMP;
  }

  if( mode == AL_USER_DECOMP ){ Find_decomp = AL_FALSE; }

  /* 
     If Find_decomp is TRUE, we proceed to find the
     decomposition
  */
  if( Find_decomp == AL_TRUE ){
    AL_Find_decomp_(sz_ptr, mode, procs);
  } else {
    for(nd=0;nd<ndim;nd++){
      s->lsize[nd] = procs[nd];
    }
  }
  
  /*
    Now we set the MPI datatypes for the ghost points
    exchange
  */
  comm = s->comm;
  
  /*
    First, we create the cartesian communicator
  */
  reord = 0;

  for(nd=0;nd<ndim;nd++){
    ldims[nd] = s->lsize[nd];
    periods[nd] = s->isperiodic[nd];
  }

#ifdef DEBUG
  if(sz_ptr==4){  /* -- print SZ_stagx -- */
     if(myrank==0) printf("MPI_Cart_create: %d x %d x %d, ndim %d, nproc %d\n",ldims[0],ldims[1],ldims[2],ndim,nproc);
  }
#endif

  MPI_Cart_create(comm, ndim, ldims, periods, reord, &cart_comm);
  
  s->cart_comm = cart_comm;

  /*
    Then we generate the cartesian topology 
    of the processors
  */
  MPI_Cart_coords(cart_comm, myrank, ndim, ldims);

  for(nd=0;nd<ndim;nd++){
    s->lrank[nd] = ldims[nd];
    MPI_Cart_shift(cart_comm, nd, 1, &nleft, &nright);
    s->left[nd] = nleft;
    s->right[nd] = nright;
  }

  /* 
     We also generate a set of 1D communicators that
     are useful when doing global operations along
     single directions.
  */
  {
    int rem_dims[AL_MAX_DIM];

    for(nd=0;nd<ndim;nd++){
      for(i=0;i<ndim;i++){ 
    if( i==nd ) { 
      rem_dims[i] = AL_TRUE;
    } else {
      rem_dims[i] = AL_FALSE;
    }
      }
      MPI_Cart_sub(cart_comm, rem_dims, &(s->oned_comm[nd]));
    }
  }
  
  /*
    Now we create the strided data types for the 
    exchange of the ghost points
  */

  /*
    Get the local array indexes (in global addressing mode)
  */
  AL_Global_to_local_(sz_ptr);

  /*
    Set the size of the local buffer for this array 
  */
  s->buffsize = 1;
  for(nd=0;nd<ndim;nd++){
    s->buffsize *=
      ( (s->end[nd]) - (s->beg[nd]) + (s->bg[nd]) + (s->eg[nd]) + 1 );
  }

#ifdef AL_GATHER_INDEXES

  /*
    If it has not yet been done, allocate the array of begs
    and ends, then gather the indexing information from all
    processors. We check that the array of 'begs' was not
    previously allocated, in order to avoid problems with
    duplicated descriptors.
  */
/*   if( (s->begs) )  free(s->begs); */

  if( !(s->begs = (int *)malloc(sizeof(int)*nproc*ndim*2))) {
    printf("AL_Decompose: could not allocate s->begs\n");
  }
  s->ends = s->begs + nproc*ndim;

  /* Gather the 'beg' index information from all nodes */
  MPI_Allgather(s->beg, ndim, MPI_INT, s->begs, ndim, MPI_INT, comm);

  /* Gather the 'end' index information from all nodes */
  MPI_Allgather(s->end, ndim, MPI_INT, s->ends, ndim, MPI_INT, comm);

#endif /* End #ifdef AL_GATHER_INDEXES */

  /* -- Set the type size of the array -- */

  MPI_Type_size(s->type, &(s->type_size));

  /*--------------------- Begin creation of strided data types -------*/

  /*
    Set the count, blocklen, and stride elements for
    the MPI_Vector calls.
    This is VERY, VERY cryptic, but it seems to work ..
  */

  /* Right->Left exchange */
  for(nd=0;nd<ndim;nd++){
    count[nd] = 1;
    blocklen[nd] = s->bg[nd];
    stride[nd] = s->larrdim_gp[nd]; 
    for(nb=0;nb<nd;nb++){
      blocklen[nd] *= s->larrdim_gp[nb];
      stride[nd]   *= s->larrdim_gp[nb];
    }
    for(nb=nd+1;nb<ndim;nb++){
      count[nd] *= s->larrdim_gp[nb];
    }
  }

  itype = s->type;
  for(nd=0;nd<ndim;nd++){
    if( count[nd] != 1){
      MPI_Type_vector( count[nd], blocklen[nd], stride[nd], itype, &ivector);
    } else {
      MPI_Type_contiguous( blocklen[nd], itype, &ivector);
    }
    MPI_Type_commit(&ivector);
    s->strided[nd] = ivector;
    s->type_rl[nd] = ivector;
  }

  /* Left->Right exchange */
  for(nd=0;nd<ndim;nd++){
    count[nd] = 1;
    /* If the array is staggered, we give 
       unique ownership of the overlapping
       point to the LEFT processor */
    if( s->isstaggered[nd] == AL_TRUE ){
      blocklen[nd] = s->bg[nd]+1;
    } else {
       blocklen[nd] = s->bg[nd];
    }

    stride[nd] = s->larrdim_gp[nd];
    for(nb=0;nb<nd;nb++){
      blocklen[nd] *= s->larrdim_gp[nb];
      stride[nd]   *= s->larrdim_gp[nb];
    }
    for(nb=nd+1;nb<ndim;nb++){
      count[nd] *= s->larrdim_gp[nb];
    }
  }

  itype = s->type;
  for(nd=0;nd<ndim;nd++){
    if( count[nd] != 1){
      MPI_Type_vector( count[nd], blocklen[nd], stride[nd], itype, &ivector);
    } else {
      MPI_Type_contiguous( blocklen[nd], itype, &ivector);
    }
    MPI_Type_commit(&ivector);
    s->type_lr[nd] = ivector;
  }

  /*--------------------- End creation of strided data types -------*/

  /* 
     Create the buffer pointers to the array
     for the SendRecv operations
  */
  MPI_Type_size( s->type, &type_size);

  for(nd=0;nd<ndim;nd++){
    s->tag1[nd] = nd*100;
    s->tag2[nd] = nd*100+1;
    /* This is the correction for a staggered mesh */
    if( s->isstaggered[nd] == AL_TRUE ){
      stagpt = 1;
    } else { 
      stagpt = 0; 
    }
    
    s->sendb1[nd] = s->lbeg[nd]             + stagpt;
    s->recvb1[nd] = s->lend[nd]+1;
    s->sendb2[nd] = s->lend[nd]-s->bg[nd]+1 - stagpt;
    s->recvb2[nd] = 0;

    for(nb=0;nb<nd;nb++){
      s->sendb1[nd] *= s->larrdim_gp[nb];
      s->recvb1[nd] *= s->larrdim_gp[nb];
      s->sendb2[nd] *= s->larrdim_gp[nb];
      s->recvb2[nd] *= s->larrdim_gp[nb];
    }

    /* 
       The buffer will be considered as char, so we
       have to correct for the size of the data  type
    */
    s->sendb1[nd] *= type_size;
    s->recvb1[nd] *= type_size;
    s->sendb2[nd] *= type_size;
    s->recvb2[nd] *= type_size;

  }

  /*
    Create the subarrays for the MPI-IO operations
  */
  {
    int istag;
 
    MPI_Datatype igsubarr, ilsubarr;

    MPI_Datatype igsubarr_stag[AL_MAX_DIM];
    MPI_Datatype ilsubarr_stag[AL_MAX_DIM];

    /* -----------------------------------------------------
        Create the global subarray for MPI_Set_file_view 
       ----------------------------------------------------- */

    for(nd=0;nd<ndim;nd++){
      gdims[nd]  = s->arrdim[nd];
      ldims[nd]  = s->larrdim[nd];
      starts[nd] = s->beg[nd] - s->bg[nd];
    }
#ifdef DEBUG
  if(sz_ptr==4){  /* print SZ_stagx */
printf("%d, gsubarr: gdims[0:2] %d,%d,%d, ldims[0:2] %d,%d,%d, starts[0:2] %d,%d,%d\n", s->rank, gdims[0], gdims[1], gdims[2], ldims[0], ldims[1], ldims[2], starts[0], starts[1], starts[2]);
}
#endif

    AL_Type_create_subarray(ndim, gdims, ldims, starts,
                            AL_ORDER_FORTRAN, s->type, &igsubarr); 
    MPI_Type_commit(&igsubarr);
    s->gsubarr = igsubarr;

    /* -----------------------------------------------------
        Create the global staggered subarrays
        for MPI_Set_file_view 
       ----------------------------------------------------- */

    for (istag = 0; istag < ndim; istag++){
      for(nd = 0; nd < ndim; nd++){
        gdims[nd]  = s->arrdim[nd];
        ldims[nd]  = s->larrdim[nd];
        starts[nd] = s->beg[nd] - s->bg[nd];
      }
      /* --------------------------------------------------------------- */
      /*! <b> Bug fixed on Aug 26, 2012:</b>  
          When the global view of the file for a staggered
          variable is computed, the gdims[nd] has to be computed
          and then passed to the function AL_Type_create_subarray. 
          
          Since gdims[nd]=s->arrdim[nd], and in s->arrdim[nd] is 
          taking into account that the variable is staggered, we comment 
          the line "gdims[istag]++;" because it is no more needed. */
      /* --------------------------------------------------------------- */
        /* gdims[istag]++; */



      /* --------------------------------------------------------------- */
      /*! <b> Bug fixed on Aug 26, 2012: </b>
          The following "if" has been modified:

          OLD version:
          if (s->beg[istag] == s->bg[istag]) {
             ldims[istag]++; 
          }else{ 
             starts[istag]++; 
          }
  
          NEW version: 
          if (s->beg[istag] == s->bg[istag]) {
          }else{ 
             starts[istag]++; 
             ldims[istag]--; 
          }
  
          \li "ldims[istag]++;" has been cancelled from the firt part
              of the if for the same motivation explaned before; 
          \li "ldims[istag]--;" has been added in the second part of the
              if because in PLUTO the index of the staggered variables 
              start from -1, while in the ArrayLib they start from 0. */
      /* --------------------------------------------------------------- */

      if (s->beg[istag] == s->bg[istag]) {
      }else{ 
        starts[istag]++; 
        ldims[istag]--; 
      }

#ifdef DEBUG
  if(sz_ptr==4){  /* print SZ_stagx */
    printf("%d, gsubarr_stag[%d]: gdims[0:2] %d,%d,%d, ldims[0:2] %d,%d,%d, starts[0:2] %d,%d,%d \n", s->rank, istag, gdims[0], gdims[1], gdims[2], ldims[0], ldims[1], ldims[2], starts[0], starts[1], starts[2]);
}
#endif

      AL_Type_create_subarray(ndim, gdims, ldims, starts,
                              AL_ORDER_FORTRAN, s->type, igsubarr_stag + istag); 
      MPI_Type_commit(igsubarr_stag + istag);
      s->gsubarr_stag[istag] = igsubarr_stag[istag];
    }

    /* -----------------------------------------------------
        Create the local subarray for the MPI_Set_write_all 
       ----------------------------------------------------- */

    for(nd=0;nd<ndim;nd++){
      gdims[nd]  = s->larrdim_gp[nd];
      ldims[nd]  = s->larrdim[nd];
      starts[nd] = s->lbeg[nd];
    }
#ifdef DEBUG
  if(sz_ptr==4){  /* print SZ_stagx */
printf("%d, lsubarr: gdims[0:2] %d,%d,%d, ldims[0:2] %d,%d,%d, starts[0:2] %d,%d,%d \n", s->rank, gdims[0], gdims[1], gdims[2], ldims[0], ldims[1], ldims[2], starts[0], starts[1], starts[2]);
}
#endif
    AL_Type_create_subarray(ndim, gdims, ldims, starts,
                 AL_ORDER_FORTRAN, s->type, &ilsubarr);
    MPI_Type_commit(&ilsubarr);
    s->lsubarr = ilsubarr;


    /* -----------------------------------------------------
        Create the local staggered subarrays
        for MPI_Set_write_all
       ----------------------------------------------------- */

    for (istag = 0; istag < ndim; istag++){
      for(nd = 0; nd < ndim; nd++){
        gdims[nd]  = s->larrdim_gp[nd];
        ldims[nd]  = s->larrdim[nd];
        starts[nd] = s->lbeg[nd];
      }
      /* --------------------------------------------------------------- */
      /*! <b> Bugs fixed on Aug 26, 2012: </b>
          The following if has been modified: 

          OLD version: 
          if (s->beg[istag] == s->bg[istag]) {
             ldims[istag]++;  
             starts[istag]--; 
          }

          NEW version:
          if (s->beg[istag] == s->bg[istag]) {
          }else{
            ldims[istag]--; 
            starts[istag]++; 
          }

          \li "ldims[istag]++;" has been cancelled from the firt part of 
              the if because when the local subarray for the MPI_Set_write_all 
              for a staggered variable is computed, the ldims[nd] has to be 
              computed and then passed to the function AL_Type_create_subarray. 
              Since ldims[nd]=s->larrdim[nd], and in s->larrdim[nd] is 
              taking into account that the variable is staggered, we remouved 
              the line "ldims[istag]++;" because it is no more needed; 
          \li "starts[istag]--;" has been cancelled from the first part of 
              the if because in PLUTO the indexes for the staggered variables 
              start locally from -1, while in ArrayLib they start from 0; 
          \li the "else" has been added to take into account the motivation
              explaned in the point before. */
      /* --------------------------------------------------------------- */

      if (s->beg[istag] == s->bg[istag]) {
      }else{
        ldims[istag]--; 
        starts[istag]++; 
      }


#ifdef DEBUG
  if(sz_ptr==4){  /* print SZ_stagx */
printf("%d, lsubarr_stag[%d]: gdims[0:2] %d,%d,%d, ldims[0:2] %d,%d,%d, starts[0:2] %d,%d,%d \n", s->rank, istag, gdims[0], gdims[1], gdims[2], ldims[0], ldims[1], ldims[2], starts[0], starts[1], starts[2]);
}
#endif
      AL_Type_create_subarray(ndim, gdims, ldims, starts,
                              AL_ORDER_FORTRAN, s->type, ilsubarr_stag + istag); 
      MPI_Type_commit(ilsubarr_stag + istag);
      s->lsubarr_stag[istag] = ilsubarr_stag[istag];
    }

  }

  /* 
     Now array is officially compiled
  */
  s->compiled = AL_TRUE;

  /* DIAGNOSTICS */
#ifdef DEBUG
  if(sz_ptr==4){  /* print SZ_stagx */
  printf("AL_Decompose: Decomposition successful\n");
  for(nd=0;nd<ndim;nd++){
    printf("AL_Decompose: %d %d\n", s->beg[nd], s->end[nd]);
  }
}
#endif

  return (int) AL_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int AL_Exchange	(	void *	vbuf,
		int	sz_ptr
	)

Fill the ghost boundaries

Parameters

[in]	vbuf	pointer to buffer
[in]	sz_ptr	integer pointer to the distributed array descriptor

Definition at line 26 of file al_exchange.c.

{
  char *buf;
  register int nd;
  int myrank, nproc;
  int ndim, gp, nleft, nright, tag1, tag2;
  int sendb, recvb;
  MPI_Datatype itype;
  MPI_Comm comm;
  MPI_Status status;
  SZ *s;

  buf = (char *) vbuf;

  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Decompose: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc = s->size;
  comm = s->comm;
  ndim = s->ndim;

  for(nd=0;nd<ndim;nd++){
    gp = s->bg[nd];
    /* If gp=0, do nothing */
    if( gp > 0 ){
      nleft = s->left[nd];
      nright = s->right[nd];
      itype = s->type_rl[nd];
      tag1 = s->tag1[nd];
      sendb = s->sendb1[nd];
      recvb = s->recvb1[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nleft, tag1,
           &buf[recvb], 1, itype, nright,tag1,
           comm, &status);

      nleft = s->left[nd];
      nright = s->right[nd];
      itype = s->type_lr[nd];
      tag2 = s->tag2[nd];

      sendb = s->sendb2[nd];
      recvb = s->recvb2[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nright, tag2,
           &buf[recvb], 1, itype, nleft,tag2,
           comm, &status);
    }
  }

  /* DIAGNOSTICS */
#ifdef DEBUG
  if(myrank==0) printf("AL_Exchange: filled ghost regions\n");
#endif

  return (int) AL_SUCCESS;
}

int AL_Exchange_dim	(	char *	buf,
		int *	dims,
		int	sz_ptr
	)

Fill the ghost boundaries along selected dimensions

Parameters

[in]	buf	pointer to buffer
[in]	dims	if dims[i]=0, do not perform the exchange in this dimension (array if int)
[in]	sz_ptr	integer pointer to the distributed array descriptor

Definition at line 24 of file al_exchange_dim.c.

{
  register int nd;
  int myrank, nproc;
  int ndim, gp, nleft, nright, tag1, tag2;
  int sendb, recvb;
  MPI_Datatype itype;
  MPI_Comm comm;
  MPI_Status status;
  SZ *s;

  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Decompose: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc = s->size;
  comm = s->comm;
  ndim = s->ndim;

  for(nd=0;nd<ndim;nd++){
    gp = s->bg[nd];
    
    /* If gp=0, do nothing */
    if( gp > 0 && dims[nd] != 0 ){
      nleft = s->left[nd];
      nright = s->right[nd];
      itype = s->type_rl[nd];
      tag1 = s->tag1[nd];

      sendb = s->sendb1[nd];
      recvb = s->recvb1[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nleft, tag1,
           &buf[recvb], 1, itype, nright,tag1,
           comm, &status);

      nleft = s->left[nd];
      nright = s->right[nd];
      itype = s->type_lr[nd];
      tag2 = s->tag2[nd];


      sendb = s->sendb2[nd];
      recvb = s->recvb2[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nright, tag2,
           &buf[recvb], 1, itype, nleft,tag2,
           comm, &status);
    }
  }

  /* DIAGNOSTICS */
#ifdef DEBUG
  if(myrank==0) printf("AL_Exchange: filled ghost regions\n"); 
#endif

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Exchange_periods	(	void *	vbuf,
		int *	periods,
		int	sz_ptr
	)

Same as AL_Exchange, but exchanges periodic boundaries at physical domain in the dim direction only if periods[dim] = 1. If a dimension is not periodic and periods[dim] = 1 nothing changes.

Parameters

[in]	vbuf	pointer to buffer
[in]	periods
[in]	sz_ptr	integer pointer to the distributed array descriptor

Definition at line 98 of file al_exchange.c.

{
  char *buf;
  register int nd;
  int myrank, nproc;
  int ndim, gp, nleft, nright, tag1, tag2;
  int sendb, recvb;
  MPI_Datatype itype;
  MPI_Comm comm;
  MPI_Status status;
  SZ *s;
  int is_beg[3], is_end[3];

  buf = (char *) vbuf;

  /* -- DIAGNOSTICS
        Check that sz_ptr points to an allocated SZ
                                                     -- */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Decompose: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc = s->size;
  comm = s->comm;
  ndim = s->ndim;

  AL_Is_boundary (sz_ptr, is_beg, is_end);

  for(nd=0;nd<ndim;nd++){
    gp = s->bg[nd];

    /* If gp=0, do nothing */

    if( gp > 0 ){
      nleft = s->left[nd];
      nright = s->right[nd];

      if (is_beg[nd] && periods[nd] == 0) nleft  = MPI_PROC_NULL;
      if (is_end[nd] && periods[nd] == 0) nright = MPI_PROC_NULL;
      
      itype = s->type_rl[nd];
      tag1 = s->tag1[nd];

      sendb = s->sendb1[nd];
      recvb = s->recvb1[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nleft, tag1,
           &buf[recvb], 1, itype, nright,tag1,
           comm, &status);

      nleft = s->left[nd];
      nright = s->right[nd];

      if (is_beg[nd] && periods[nd] == 0) nleft  = MPI_PROC_NULL;
      if (is_end[nd] && periods[nd] == 0) nright = MPI_PROC_NULL;

      itype = s->type_lr[nd];
      tag2 = s->tag2[nd];

      sendb = s->sendb2[nd];
      recvb = s->recvb2[nd];

      MPI_Sendrecv(&buf[sendb], 1, itype, nright, tag2,
           &buf[recvb], 1, itype, nleft,tag2,
           comm, &status);
    }
  }

  /* DIAGNOSTICS */
#ifdef DEBUG
  printf("AL_Exchange: filled ghost regions\n"); 
#endif

  return (int) AL_SUCCESS;
}

Here is the call graph for this function:

int AL_File_close

(

int

sz_ptr

)

Close a file associate with and array

Parameters

[in]

sz_ptr

integer pointer to array descriptor

Definition at line 83 of file al_io.c.

{
  int myrank;
  int errcode;
  SZ *s;

  s = sz_stack[sz_ptr];
  myrank = s->rank;

  errcode =  MPI_File_close(&(s->ifp));

  /* DIAGNOSTICS */
#ifdef DEBUG
  int myid, len;
  char es[128];
  if( errcode ){
     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
     MPI_Error_string(errcode, es, &len);
     printf("Errcode from MPI_File_close: %d | %s\n", errcode, es);
  }
  printf("myid %d, AL_File_close: Closed file, errcode %d \n",myid, errcode);
#endif

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_File_open	(	char *	filename,
		int	sz_ptr
	)

Open a file associated with a distributed array

Parameters

[in]	filename	name of the file
[in]	sz_ptr	integer pointer to the distributed array descriptor

Returns

ifp pointer to integer file pointer

Definition at line 27 of file al_io.c.

{
  int myrank, nproc;
  int errcode;
  MPI_File ifp;
  MPI_Comm comm;
  SZ *s;

  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Decompose: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc = s->size;

  comm = s->comm;

  MPI_Barrier(comm);

  errcode = MPI_File_open(comm, filename,
        MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_UNIQUE_OPEN,
        MPI_INFO_NULL, &ifp);

  s->io_offset = 0;
  s->ifp = ifp;

  /* DIAGNOSTICS */
#ifdef DEBUG
  int myid, len;
  char es[128];
  MPI_Comm_rank(MPI_COMM_WORLD, &myid);
  if( errcode ){
     MPI_Error_string(errcode, es, &len);
     printf("Errcode from MPI_File_open: %d | %s\n", errcode, es);
  }
  printf("myid %d, AL_File_open: Opened file %s\n",myid,filename);
#endif

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Finalize

(

)

Finalize the AL Tool. It contains a call to MPI_Finalize()

Definition at line 15 of file al_finalize.c.

{
  int myrank, nproc, errcode;

  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  MPI_Comm_size(MPI_COMM_WORLD, &nproc);

  /* Synchronize just in case */
  MPI_Barrier(MPI_COMM_WORLD);

  errcode = MPI_Finalize();

#ifdef DEBUG
  printf("AL_Finalize: Called MPI_Finalize: %d\n",errcode);
#endif

  return errcode;
}

Here is the caller graph for this function:

int AL_Free

(

int

)

int AL_Get_bounds	(	int	isz,
		int *	beg,
		int *	end,
		int *	gp,
		int	style
	)

Get the global indexes for the local portion of a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	beg	Array of ndim integers containing the start points
[out]	end	Array of ndim integers containing the end points
[out]	gp	Array of ndim integers containing the ghost points
[in]	style	Index style: AL_C_INDEXES or AL_FORTRAN_INDEXES

Definition at line 707 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_gbounds: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    beg[i] = s->beg[i];
    end[i] = s->end[i];
    gp[i] = s->bg[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Get_buffsize	(	int	sz_ptr,
		int *	buffsize
	)

Get the local buffer size for a distributed array, including the number of elements of the ghsot regions.

Parameters

[in]	sz_ptr	Integer pointer to the input array descriptor
[out]	buffsize	Buffer size [in number of elements]

Definition at line 242 of file al_sz_get.c.

{
  int isz;
  SZ *s;

  isz = sz_ptr;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_buffsize: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  *buffsize = s->buffsize;

  return (int) AL_SUCCESS;
}

int AL_Get_cart_comm	(	int	isz,
		MPI_Comm *	cart_comm
	)

Get the cartesian communicator for a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	cart_comm	Pointer to cartesian communicator

Definition at line 117 of file al_sz_get.c.

{
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_comm: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  *cart_comm = s->cart_comm;

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Get_comm	(	int	isz,
		MPI_Comm *	comm
	)

Get the communicator for a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	comm	Pointer to communicator

Definition at line 87 of file al_sz_get.c.

{
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_comm: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  *comm = s->comm;

  return (int) AL_SUCCESS;
}

int AL_Get_dimensions	(	int	isz,
		int *	ndim
	)

Get the dimensions of the distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	ndim	Pointer to integer number of dimensions

Definition at line 148 of file al_sz_get.c.

{
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_dimensions: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  *ndim = s->ndim;

  return (int) AL_SUCCESS;
}

int AL_Get_gbounds	(	int	isz,
		int *	gbeg,
		int *	gend,
		int *	gp,
		int	style
	)

Get the global bounds of the global array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	gbeg	Array of ndim integers containing the start points
[out]	gend	Array of ndim integers containing the end points
[out]	gp	Array of ndim integers containing the ghost points
[in]	style	Index style: AL_C_INDEXES or AL_FORTRAN_INDEXES

Definition at line 746 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_gbounds: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    gbeg[i] = s->bg[i];
    gend[i] = s->arrdim[i]+s->bg[i]-1;
    gp[i] = s->bg[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Get_ghosts	(	int	isz,
		int *	ghosts
	)

Get the ghost points of the distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	ghost	Array of integers with size of ghost points in each dimension

Definition at line 633 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_ghosts: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    ghosts[i] = s->bg[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_global_dim	(	int	isz,
		int *	gdims
	)

Get the global dimensions of the distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	gdims	Array of integers with global dimensions

Definition at line 276 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_global_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ gdims[i] = s->arrdim[i];}

  return (int) AL_SUCCESS;
}

int AL_Get_lbounds	(	int	isz,
		int *	lbeg,
		int *	lend,
		int *	gp,
		int	style
	)

Get the local indexes for the local portion of a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	lbeg	Array of ndim integers containing the start points
[out]	lend	Array of ndim integers containing the end points
[out]	gp	Array of ndim integers containing the ghost points
[in]	style	Index style: AL_C_INDEXES or AL_FORTRAN_INDEXES

Definition at line 668 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_lbounds: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    lbeg[i] = s->lbeg[i];
    lend[i] = s->lend[i];
    gp[i] = s->bg[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Get_local_dim	(	int	isz,
		int *	ldims
	)

Get the local dimensions of a distributed array WITHOUT GHOST POINTS

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	ldims	Array of integers with local dimensions

Definition at line 309 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_local_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ ldims[i] = s->larrdim[i];}

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Get_local_dim_gp	(	int	sz_ptr,
		int *	ldims_gp
	)

Get the local dimensions of a distributed array WITH GHOST POINTS

Parameters

[in]	sz_ptr	Integer pointer to the input array descriptor
[out]	ldims_gp	Array of integers with local dimensions (including ghost points)

Definition at line 341 of file al_sz_get.c.

{
  register int i;
  int isz;
  int ndim;
  SZ *s;

  isz = sz_ptr;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_local_dim_gp: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ ldims_gp[i] = s->larrdim_gp[i];}

  return (int) AL_SUCCESS;
}

long long AL_Get_offset

(

int

)

Definition at line 327 of file al_io.c.

{
  SZ *s;

  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Get_offset: wrong SZ pointer\n");
  }
  s  = sz_stack[sz_ptr];
  return s->io_offset;
}

Here is the caller graph for this function:

int AL_Get_offsets	(	int	sz_ptr,
		int *	offset
	)

Get the offsets for the for loop index calculation

NOTE: The typical multidimensional C for loop will look like, for example:

... ;

AL_Get_offsets(sz_ptr, offset);

for(k=kbeg; k<=kend; k++){ koff = k*offset[2]; for(j=jbeg; j<=jend; j++){ joff = j*offset[1]; for(i=ibeg; i<=iend; i++){ ioff = i*offset[0]+joff+koff; a[ioff] = ... ; } } } ... ;

Where a[ioff] is a generic 3D array.

Parameters

[in]	sz_ptr	Integer pointer to the input array descriptor
[out]	offset	Array of integers with offsets

Definition at line 378 of file al_sz_get.c.

{
  register int i;
  int isz;
  int ndim;
  SZ *s;

  isz = sz_ptr;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_offsets: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    offset[i] = s->offset[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_parallel_dim	(	int	isz,
		int *	pardims
	)

Get the parallel dimensions of a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	pardims	Array of integers with parallel dimensions [AL_TRUE|AL_FALSE]

Definition at line 528 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_parallel_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    pardims[i] = s->isparallel[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_periodic_dim	(	int	isz,
		int *	periods
	)

Get the periodic dimensions of the distributed arrays

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	periods	Array of integers with periodic dimensions [AL_TRUE|AL_FALSE]

Definition at line 563 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_periodic_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    periods[i] = s->isperiodic[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_size	(	int	isz,
		int *	size
	)

Get the size of the communicator associated with a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor (input)
[in]	size	Integer pointer to size (output)

Definition at line 23 of file al_sz_get.c.

{
  int nproc;
  MPI_Comm comm;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_comm: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  comm = s->comm;

  MPI_Comm_size(comm, &nproc);

  *size = nproc;

  return (int) AL_SUCCESS;
}

int AL_Get_staggered_dim	(	int	isz,
		int *	stagger
	)

Get the staggered dimensions of the distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	stagger	Array of integers with staggered dimensions [AL_TRUE|AL_FALSE]

Definition at line 598 of file al_sz_get.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_staggered_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    stagger[i] = s->isstaggered[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_stride	(	int	sz_ptr,
		int *	stride
	)

Get the strides for the for loop index calculation NOTE: The typical multidimensional C for loop will look like, for example:

... ;

AL_Get_stride(sz_ptr, stride);

for(k=kbeg; k<=kend; k++){ koff = k*stride[2]; for(j=jbeg; j<=jend; j++){ joff = j*stride[1]; for(i=ibeg; i<=iend; i++){ ioff = i*stride[0]+joff+koff; a[ioff] = ... ; } } } ... ;

Where a[ioff] is a generic 3D array.

Parameters

[in]	sz_ptr	Integer pointer to the input array descriptor
[out]	stride	Array of strides

Definition at line 437 of file al_sz_get.c.

{
  register int i;
  int isz;
  int ndim;
  SZ *s;

  isz = sz_ptr;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_offsets: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];
  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    stride[i] = s->stride[i];
  }

  return (int) AL_SUCCESS;
}

int AL_Get_type	(	int	isz,
		AL_Datatype *	type
	)

Get the basic data type of a distributed array

Parameters

[in]	isz	Integer pointer to the input array descriptor
[out]	type	Pointer to datatype

Definition at line 177 of file al_sz_get.c.

{
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Get_type: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  *type = s->type;

  return (int) AL_SUCCESS;
}

int AL_Init	(	int *	argc,
		char ***	argv
	)

Initialize the AL Tool. It contains a call to MPI_Init().

Parameters

[in]	argc	integer pointer to number of arguments
[in]	argv	pointer to argv list

Definition at line 18 of file al_init.c.

{
  int myrank, nproc, errcode;
  int flag;

  errcode = MPI_Initialized(&flag);

  if( !flag ) 
    errcode = MPI_Init(argc, argv);

  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  MPI_Comm_size(MPI_COMM_WORLD, &nproc);

#ifdef DEBUG
  printf("AL_Init: Called MPI_init from C: %d\n",errcode);
#endif

  /* Initialize the SZ pointers stack */
  AL_Init_stack_();

  /* Synchronize just in case */
  MPI_Barrier(MPI_COMM_WORLD);

  AL_initialized = AL_TRUE;

  return errcode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int AL_Init_stack_

(

)

Initialize the stack of SZ pointers This routine is called internally by AL_Init.

Definition at line 33 of file al_szptr_.c.

{
  register int i;
  int myrank;

  stack_top  = 0;
  stack_used = 0;

  for( i=0; i<AL_MAX_ARRAYS;i++){ stack_ptr[i] = AL_STACK_FREE ;}

  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  
#ifdef DEBUG
  printf("AL_Init_stack_: SZ stack initialized\n");
#endif

  return 0;
}

Here is the caller graph for this function:

int AL_Initialized

(

)

Test whether or not AL was initialized

Returns

This function returns AL_TRUE if AL is initialized, AL_FALSE otherwise.

Definition at line 53 of file al_init.c.

{
  return AL_initialized;
}

int AL_Is_boundary	(	int	sz_ptr,
		int *	is_gbeg,
		int *	is_gend
	)

This routine is useful when implementing the physical boundary conditions on a problem. It returns two arrays that are set to AL_TRUE or AL_FALSE depending on wether or not the local beginning (ending) address for the array in each direction is actually a global one.

Parameters

[in]	sz_ptr	pointer to a distributed array descriptor (integer)
[out]	is_gbeg	int array set to AL_TRUE or AL_FALSE for global beginning
[out]	is_gend	int array set to AL_TRUE or AL_FALSE for global ending

Definition at line 28 of file al_boundary.c.

{
  register int i;
  int myrank, nproc,ndims;
  MPI_Comm comm;
  SZ *s;

  /* DIAGNOSTICS
    Check that sz_ptr points to an allocated SZ
  */
  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Is_boundary: wrong SZ pointer\n");
  }

  s = sz_stack[sz_ptr];

  myrank = s->rank;
  nproc  = s->size;
  comm   = s->comm;
  ndims  = s->ndim;

  for(i=0;i<ndims;i++){
    if( s->beg[i]  == s->bg[i] ){
      is_gbeg[i] = AL_TRUE;
    } else {
      is_gbeg[i] = AL_FALSE;
    }
    if( s->end[i] == s->arrdim[i]+s->bg[i]-1 ){
      is_gend[i] = AL_TRUE;
    } else {
      is_gend[i] = AL_FALSE;
    }
  }

  /* DIAGNOSTICS */
#ifdef DEBUG
    printf("AL_Is_boundary: completed\n");
#endif

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Read_array	(	void *	va,
		int	sz_ptr,
		int	istag
	)

Read a distributed array to a file in parallel using synchronous and collective IO operations

Parameters

[in]	buffer	pointer to the buffer to write
[in]	sz_ptr	integer pointer to a distributed array descriptor
[in]	istag	set it to -1 for centred variables, set to 0,1,2 for staggered field in the x,y,z direction

Bugs fixed on Aug 26, 2012:

• nelem has been declared long long in order to manage dbl and flt output 'single_file' in which each PLUTO variable is >= 4GB
• the updating of nelem after the writing of a variable has been modified from ''nelem *= (long long)(s->arrdim[i] +(istag == i));'' to ''nelem *= (long long)(s->arrdim[i]);'' because when a staggered variable is written, in the sz_ptr descriptor there is the information about the really number of element of this variable. This appens because the function AL_Set_staggered_dim is called for a staggered array.

Definition at line 209 of file al_io.c.

{
  char *a;
  register int i;
  int myrank;
  long long nelem;
  SZ *s;
  MPI_Status status;
  AL_Datatype gsub_arr, lsub_arr;


  MPI_File ifp;
  MPI_Offset offset;
  int size;

  a = (void *)va;

  s = sz_stack[sz_ptr];
  myrank = s->rank;

  ifp = s->ifp;

  offset   = s->io_offset;
  if (istag == -1){
    gsub_arr = s->gsubarr;
    lsub_arr = s->lsubarr;
  }else{
    gsub_arr = s->gsubarr_stag[istag];
    lsub_arr = s->lsubarr_stag[istag];
  }

  MPI_Barrier(s->comm);

  MPI_File_set_view(ifp, offset, MPI_BYTE, gsub_arr,
            "native", MPI_INFO_NULL);
  MPI_File_read_all(ifp, a, 1, lsub_arr, &status);
  
  MPI_Type_size( s->type, &size);

  nelem = 1;
  for(i = 0; i < s->ndim; i++) {
/* -------------------------------------------------------------------- */
/*!  Bugs fixed on Aug 26, 2012:
  \li nelem has been declared long long in order to manage dbl and flt 
     output 'single_file' in which each PLUTO variable is >= 4GB
  \li the updating of nelem after the writing of a variable has been 
     modified from  ''nelem *= (long long)(s->arrdim[i] +(istag == i));''
     to ''nelem *= (long long)(s->arrdim[i]);'' because when a staggered 
     variable is written, in the sz_ptr descriptor there is the 
     information about the really number of element of this variable.  
     This appens because the function AL_Set_staggered_dim is called 
     for a staggered array. */
/* -------------------------------------------------------------------- */
/*    nelem *= (long long)(s->arrdim[i] + (istag == i)); */
    nelem *= (long long)(s->arrdim[i]); 
  }
  s->io_offset += (long long)(size)*nelem;

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Read_common	(	void *	,
		int	,
		AL_Datatype	,
		int
	)

int AL_Set_comm	(	MPI_Comm	comm,
		int	isz
	)

Set the communicator for a distributed array

Parameters

[in]	comm	MPI communicator the array is associated with
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the communicator is set correctly, AL_FAILURE otherwise.

Definition at line 24 of file al_sz_set.c.

{
  int myrank, nproc;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_comm: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  MPI_Comm_rank(comm, &myrank);
  MPI_Comm_size(comm, &nproc);

  s->comm = comm;
  s->size = nproc;
  /*
    Patch for the case in which this node does not
    belong to this communicator 
  */
  if( nproc > 0 ) {
    s->rank = myrank;
  } else { s->rank = MPI_UNDEFINED; }

  return (int) AL_SUCCESS;
}

int AL_Set_dimensions	(	int	ndim,
		int	isz
	)

Set the dimensions of a distributed array

Parameters

[in]	ndim	Number of dimensions (1 to 5)
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the dimensions are set correctly, AL_FAILURE otherwise.

Definition at line 69 of file al_sz_set.c.

{
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_dimensions: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  s->ndim = ndim;

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_ghosts	(	int *	ghosts,
		int	isz
	)

Set the ghost points of a distributed array

Parameters

[in]	ghost	Array of integers with size of ghost points in each dimension
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the ghost points are set correctly, AL_FAILURE otherwise.

Definition at line 333 of file al_sz_set.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_ghosts: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    s->bg[i] = ghosts[i];
    s->eg[i] = ghosts[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_global_dim	(	int *	gdims,
		int	isz
	)

Set the global dimensions of a distributed array

Parameters

[in]	gdims	Array of integers with global dimensions
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the global dimension are set correctly, AL_FAILURE otherwise.

Definition at line 141 of file al_sz_set.c.

{
  register int i;
  int ndim;

  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_global_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ s->arrdim[i] = gdims[i] ;}

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_local_dim	(	int *	ldims,
		int	isz
	)

Set the local dimensions of a distributed array

Parameters

[in]	ldims	Array of integers with local dimensions
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the local dimension are set correctly, AL_FAILURE otherwise.

Definition at line 177 of file al_sz_set.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_local_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    s->larrdim[i] = ldims[i];
    s->lbeg[i] = 0;
    s->lend[i] = ldims[i]-1;
  }

  return (int) AL_SUCCESS;
}

int AL_Set_offset	(	int	,
		long	long
	)

Definition at line 342 of file al_io.c.

{
  SZ *s;

  if( stack_ptr[sz_ptr] == AL_STACK_FREE){
    printf("AL_Get_offset: wrong SZ pointer\n");
  }
  s  = sz_stack[sz_ptr];
  s->io_offset = offset;
  return (int)AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_parallel_dim	(	int *	pardims,
		int	isz
	)

Set the parallel dimensions of a distributed array

Parameters

[in]	pardims	Array of integers with parallel dimensions [AL_TRUE|AL_FALSE]
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the parallel dimension are set correctly, AL_FAILURE otherwise.

Definition at line 216 of file al_sz_set.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_parallel_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    s->isparallel[i] = pardims[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_periodic_dim	(	int *	periods,
		int	isz
	)

Set the periodic dimensions of a distributed array

Parameters

[in]	periods	Array of integers with periodic dimensions [AL_TRUE|AL_FALSE]
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the periodic dimension are set correctly, AL_FAILURE otherwise.

Definition at line 253 of file al_sz_set.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_periodic_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    if( periods[i] != AL_TRUE && periods[i] != AL_FALSE ){
      printf("Warning: periods has illegal values in AL_Set_periodic_dim\n");
    }
    s->isperiodic[i] = periods[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_staggered_dim	(	int *	stagger,
		int	isz
	)

Set the staggered dimensions of a distributed array

Parameters

[in]	stagger	Array of integers with staggered dimensions [AL_TRUE|AL_FALSE]
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the staggered dimension are set correctly, AL_FAILURE otherwise.

Definition at line 293 of file al_sz_set.c.

{
  register int i;
  int ndim;
  SZ *s;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_staggered_dim: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  ndim = s->ndim;
  for(i=0;i<ndim;i++){ 
    if( stagger[i] != AL_TRUE && stagger[i] != AL_FALSE ){
      printf("Warning: stagger has illegal values in AL_Set_staggered_dim\n");
    }
    s->isstaggered[i] = stagger[i];
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Set_type	(	AL_Datatype	type,
		int	nelem,
		int	isz
	)

Set the basic data type of a distributed array. The data types are identical to the MPI datatypes, and they can be defined as AL_<type> or MPI_<type> (e.g. AL_FLOAT or MPI_FLOAT).

Parameters

[in]	type	Datatype (AL_Datatype or MPI_Datatype)
[in]	nelem	Number of type 'type' elements in array elements
[out]	isz	Integer pointer to the input array descriptor

Returns

AL_SUCCESS if the type is set correctly, AL_FAILURE otherwise.

Definition at line 101 of file al_sz_set.c.

{
  SZ *s;
  AL_Datatype ivector;

  /* 
     Check that isz points to an allocated SZ
  */
  if( stack_ptr[isz] == AL_STACK_FREE ){
    printf("AL_Set_type: wrong SZ pointer\n");
    return (int) AL_FAILURE;
  }

  /*
    Get the SZ structure isz is pointing at
  */
  s = sz_stack[isz];

  if( nelem <= 1 ){
    s->type = type;
  } else {
    MPI_Type_contiguous( nelem, type, &ivector);
    MPI_Type_commit(&ivector);
    s->type = ivector;
  }

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Sort_	(	int	n,
		int *	in,
		int *	ind
	)

Sort and array of integers

This is a really simple implementation, since we do not really use this for large arrays.

Parameters

[in]	n	size of input array (integer)
[in]	in	input array
[in]	ind	array of the sorted index arrays (max to min)

Definition at line 15 of file al_sort_.c.

{
  register int i, temp;
  int m, r, s;
  
  /* Start with the normal index ordering */
  for(i=0;i<n;i++) ind[i]=i;

  m=0;
  while(m<n) {
    r = m;
    s = in[m];
    for(i=m+1;i<n;i++) if( in[ind[i]] > s ) { r=i; s=in[ind[i]]; }
    swapi_(ind[m],ind[r]);
    m++;
  }
  return 0;
}

Here is the caller graph for this function:

int AL_Sz_free

(

int

sz_ptr

)

Dellocate a distributed array descriptor

Parameters

[in]

sz_ptr

Integer pointer to the array descriptor

Definition at line 23 of file al_sz_free.c.

{
  /*
    Deallocate the SZ structure 
  */
  return AL_Deallocate_sz_(sz_ptr);

}

Here is the call graph for this function:

int AL_Sz_init	(	MPI_Comm	comm,
		int *	sz_ptr
	)

Allocate and initialize a distributed array descriptor

Parameters

[in]	comm	MPI communicator the array is associated with
[out]	sz_ptr	Integer pointer to the array descriptor

Returns

AL_SUCCESS if the array descriptor is correct initialized, AL_FAILURE otherwise.

Definition at line 22 of file al_sz_init.c.

{
  int myrank, nproc;
  register int i;

  /*
    If this process does not belong to the communicator,
    or if the communicator is MPI_COMM_NULL, return a
    AL_UNDEFINED pointer
  */
  if( comm == MPI_COMM_NULL ) {
    *sz_ptr = AL_UNDEFINED;
    return AL_FAILURE;
  }

  /*
    Allocate the SZ structure 
  */
  *sz_ptr = AL_Allocate_sz_();

  MPI_Comm_rank(comm, &myrank);
  MPI_Comm_size(comm, &nproc);

  /*
    Set the initial entries
  */
  sz_stack[*sz_ptr]->compiled = AL_FALSE; /* The array is not compiled yet */
  sz_stack[*sz_ptr]->comm = comm;
  sz_stack[*sz_ptr]->rank = myrank;
  sz_stack[*sz_ptr]->size = nproc;

  /* 
     Set some defaults 
  */
  sz_stack[*sz_ptr]->type = MPI_DOUBLE;
  for(i=0;i<AL_MAX_DIM;i++){
    sz_stack[*sz_ptr]->isparallel[i] = AL_TRUE;
    sz_stack[*sz_ptr]->isperiodic[i] = AL_TRUE;
    sz_stack[*sz_ptr]->isstaggered[i] = AL_FALSE;
    sz_stack[*sz_ptr]->larrdim_gp[i]=1;
    sz_stack[*sz_ptr]->larrdim[i]=1;
    sz_stack[*sz_ptr]->arrdim[i]=1;
    sz_stack[*sz_ptr]->beg[i]=0;
    sz_stack[*sz_ptr]->end[i]=0;
    sz_stack[*sz_ptr]->lbeg[i]=0;
    sz_stack[*sz_ptr]->lend[i]=0;
    sz_stack[*sz_ptr]->bg[i]=0;
    sz_stack[*sz_ptr]->eg[i]=0;
    sz_stack[*sz_ptr]->offset[i]=1;
    sz_stack[*sz_ptr]->stride[i]=1;
  }

  sz_stack[*sz_ptr]->begs = NULL;
  sz_stack[*sz_ptr]->ends = NULL;

  return (int) AL_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int AL_Type_create_subarray	(	int	ndims,
		int *	array_of_sizes,
		int *	array_of_subsizes,
		int *	array_of_starts,
		int	order,
		MPI_Datatype	oldtype,
		MPI_Datatype *	newtype
	)

Creates a datatype describing a subarray of a multidimensional array NOTE: This routine has been modified from R. Thakur's ROMIO implementation of MPI_Type_create_subarry. The reason for keeping a local copy is mainly to reduce this package's dependence on ROMIO. It only affects the non I/O components of the library (e.g. AL_Allgather).

Parameters

[in]	ndims	number of array dimensions
[in]	array_of_sizes	number of elements of type oldtype in each dimension of the full array
[in]	array_of_subsizes	number of elements of type oldtype in each dimension of the subarray
[in]	array_of_starts	starting coordinates of the subarray in each dimension
[in]	order	array storage order flag
[in]	oldtype	old datatype (handle)
[out]	newtype	new datatype (handle)

Definition at line 18 of file al_subarray_.c.

{
    MPI_Aint extent, disps[AL_MAX_DIM], size, size_with_aint;
    int i, blklens[AL_MAX_DIM];
    MPI_Datatype tmp1, tmp2, types[AL_MAX_DIM];
    MPI_Offset size_with_offset;

    if (ndims <= 0) {
        printf("MPI_Type_create_subarray: Invalid ndims argument\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
    if (array_of_sizes <= (int *) 0) {
        printf("MPI_Type_create_subarray: array_of_sizes is an invalid address\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
    if (array_of_subsizes <= (int *) 0) {
        printf("MPI_Type_create_subarray: array_of_subsizes is an invalid address\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
    if (array_of_starts <= (int *) 0) {
        printf("MPI_Type_create_subarray: array_of_starts is an invalid address\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }

    for (i=0; i<ndims; i++) {
        if (array_of_sizes[i] <= 0) {
            printf("MPI_Type_create_subarray: Invalid value in array_of_sizes\n");
            MPI_Abort(MPI_COMM_WORLD, 1);
        }
        if (array_of_subsizes[i] <= 0) {
            printf("MPI_Type_create_subarray: Invalid value in array_of_subsizes\n");
            MPI_Abort(MPI_COMM_WORLD, 1);
        }
        if (array_of_starts[i] < 0) {
            printf("MPI_Type_create_subarray: Invalid value in array_of_starts\n");
            MPI_Abort(MPI_COMM_WORLD, 1);
        }
    }

    /* order argument checked below */

    if (oldtype == MPI_DATATYPE_NULL) {
        printf("MPI_Type_create_subarray: oldtype is an invalid datatype\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }

    MPI_Type_extent(oldtype, (MPI_Aint *) &extent);

/* check if MPI_Aint is large enough for size of global array. 
   if not, complain. */

    size_with_aint = extent;
    for (i=0; i<ndims; i++) size_with_aint *= array_of_sizes[i];
    size_with_offset = extent;
    for (i=0; i<ndims; i++) size_with_offset *= array_of_sizes[i];
    if (size_with_aint != size_with_offset) {
        printf("MPI_Type_create_subarray: Can't use an array of this size unless the MPI implementation defines a 64-bit MPI_Aint\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }

    if (order == AL_ORDER_FORTRAN) {
      /* dimension 0 changes fastest */
        if (ndims == 1)
            MPI_Type_contiguous(array_of_subsizes[0], oldtype, &tmp1);
        else {
            MPI_Type_vector(array_of_subsizes[1], array_of_subsizes[0],
                            array_of_sizes[0], oldtype, &tmp1);
            
            size = array_of_sizes[0]*extent;
            for (i=2; i<ndims; i++) {
                size *= array_of_sizes[i-1];
                MPI_Type_hvector(array_of_subsizes[i], 1, size, tmp1, &tmp2);
                MPI_Type_free(&tmp1);
                tmp1 = tmp2;
            }
        }
        
        /* add displacement and UB */
        
        disps[1] = array_of_starts[0];
        size = 1;
        for (i=1; i<ndims; i++) {
            size *= array_of_sizes[i-1];
            disps[1] += size*array_of_starts[i];
        }  
        /* rest done below for both Fortran and C order */
    }

    else if (order == AL_ORDER_C) {
        /* dimension ndims-1 changes fastest */
        if (ndims == 1)
            MPI_Type_contiguous(array_of_subsizes[0], oldtype, &tmp1);
        else {
            MPI_Type_vector(array_of_subsizes[ndims-2],
                            array_of_subsizes[ndims-1],
                            array_of_sizes[ndims-1], oldtype, &tmp1);
            
            size = array_of_sizes[ndims-1]*extent;
            for (i=ndims-3; i>=0; i--) {
                size *= array_of_sizes[i+1];
                MPI_Type_hvector(array_of_subsizes[i], 1, size, tmp1, &tmp2);
                MPI_Type_free(&tmp1);
                tmp1 = tmp2;
            }
        }
        
        /* add displacement and UB */
        
        disps[1] = array_of_starts[ndims-1];
        size = 1;
        for (i=ndims-2; i>=0; i--) {
            size *= array_of_sizes[i+1];
            disps[1] += size*array_of_starts[i];
        }
    }
    else {
        printf("MPI_Type_create_subarray: Invalid order argument\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
    
    disps[1] *= extent;
    
    disps[2] = extent;
    for (i=0; i<ndims; i++) disps[2] *= array_of_sizes[i];
    
    disps[0] = 0;
    blklens[0] = blklens[1] = blklens[2] = 1;
    types[0] = MPI_LB;
    types[1] = tmp1;
    types[2] = MPI_UB;
    
    MPI_Type_struct(3, blklens, disps, types, newtype);

    MPI_Type_free(&tmp1);

    return MPI_SUCCESS;
}

Here is the caller graph for this function:

int AL_Valid_ptr

(

int

sz_ptr

)

Return AL_TRUE if the input pointer points to an allocated distributed array. Return AL_FALSE otherwise.

Parameters

[in]

sz_ptr

Integer pointer to an entry in the SZ stack

Definition at line 150 of file al_szptr_.c.

{
  if(stack_ptr[sz_ptr]!=AL_STACK_USED ) return AL_FALSE;
  return sz_stack[sz_ptr]->compiled;
}

int AL_Write_array	(	void *	va,
		int	sz_ptr,
		int	istag
	)

Write a distributed array to a file in parallel using synchronous and collective IO operations

Parameters

[in]	buffer	pointer to the buffer to write
[in]	sz_ptr	integer pointer to the distributed array descriptor
[in]	istag	set it to -1 for centred variables, set to 0,1,2 for staggered field in the x,y,z direction

Bugs fixed on Aug 26, 2012:

• nelem has been declared long long in order to manage dbl and flt output 'single_file' in which each PLUTO variable is >= 4GB
• the updating of nelem after the writing of a variable has been modified from ''nelem *= (long long)(s->arrdim[i] +(istag == i));'' to ''nelem *= (long long)(s->arrdim[i]);'' because when a staggered variable is written, in the sz_ptr descriptor there is the information about the really number of element of this variable. This appens because the function AL_Set_staggered_dim is called for a staggered array.

Definition at line 115 of file al_io.c.

{
  char *a;
  register int i;
  int myrank;
  long long nelem;
  int errcode;
  SZ *s;

  MPI_Status status;
  AL_Datatype gsub_arr, lsub_arr;

  MPI_File ifp;
  MPI_Offset offset;
  int  size;
  

  a = (char *) va;

  s = sz_stack[sz_ptr];
  myrank = s->rank;
  ifp = s->ifp;

  offset   = s->io_offset;
  if (istag == -1){
    gsub_arr = s->gsubarr;
    lsub_arr = s->lsubarr;
  }else{
    gsub_arr = s->gsubarr_stag[istag];
    lsub_arr = s->lsubarr_stag[istag];
  }

  MPI_Barrier(s->comm);

  errcode = MPI_File_set_view(ifp, offset, MPI_BYTE, gsub_arr,
                    "native", MPI_INFO_NULL);
 
#ifdef DEBUG
    int myid, len;
    char es[256];
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    if( errcode ){
      MPI_Error_string(errcode, es, &len);
      printf("Errcode from MPI_File_set_view: %d | %s\n", errcode, es);
    }
    printf("myid %d, offset file_set_view %lld\n", myid,offset);
#endif

  errcode = MPI_File_write_all(ifp, a, 1, lsub_arr, &status);

#ifdef DEBUG
    if( errcode ){
      MPI_Error_string(errcode, es, &len);
      printf("Errcode from MPI_File_write_all: %d | %s\n", errcode, es);
    }
#endif
    
  MPI_Type_size( s->type, &size);

  nelem = 1;
  for(i = 0; i < s->ndim; i++) {
/* -------------------------------------------------------------------- */
/*!  Bugs fixed on Aug 26, 2012:
  \li nelem has been declared long long in order to manage dbl and flt 
     output 'single_file' in which each PLUTO variable is >= 4GB
  \li the updating of nelem after the writing of a variable has been 
     modified from  ''nelem *= (long long)(s->arrdim[i] +(istag == i));''
     to ''nelem *= (long long)(s->arrdim[i]);'' because when a staggered 
     variable is written, in the sz_ptr descriptor there is the 
     information about the really number of element of this variable. 
     This appens because the function AL_Set_staggered_dim is called 
     for a staggered array. */
/* -------------------------------------------------------------------- */
/*    nelem *= (long long)(s->arrdim[i] +(istag == i)); */
    nelem *= (long long)(s->arrdim[i]);
  } 

  s->io_offset += (long long)(size)*nelem;

  return (int) AL_SUCCESS;
}

Here is the caller graph for this function:

int AL_Write_array_begin	(	void *	va,
		int	sz_ptr,
		int *	output_stag,
		int *	output_dump,
		int	output_nvar
	)

Write a distributed array to a parallel file by using asynchronous MPI-IO

Parameters

[in]	buffer	pointer to the buffer to write
[in]	sz_ptr	integer pointer to the distributed array descriptor
[in]	output_stag	vector sets to -1 for centred variables, and sets to 0,1,2 for staggered field in the x,y,z direction
[in]	output_dump	vector sets to 1 if the variable has to be dumped, 0 in the contrary case
[in]	output_nvar	total number of variables in PLUTO simulation

Definition at line 26 of file al_write_array_async.c.

{
  char *a;
  register int i;
  SZ *s;

  MPI_File ifp;

  int errcode;

  int myrank;
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  a = (char *) va;

  s = sz_stack[sz_ptr];
  ifp = s->ifp;

  /* Definition of a "global" filetype given by nvar times gsubarr for the MPI_File_set_view */ 
  MPI_Datatype filetype_gsub_arr; 
  int count; /* number of variable to be dumped */ 
  count=0;
  for (i=0; i<output_nvar; i++){ 
    if (!(output_dump[i]== 0)) count = count+1;
  } 
  errcode = MPI_Type_contiguous(count, s->gsubarr, &filetype_gsub_arr);
  errcode = MPI_Type_commit(&filetype_gsub_arr); 
  
  /* Definition of a "global" datatype for the MPI_File_write_all_begin */ 
  MPI_Datatype dtype_lsub_arr; 

#ifdef DEBUG
  if(myrank==0) printf("count=%d, output_nvar=%d\n",count,output_nvar);
#endif

  int *block_leng, *displ;
  int k=0;

  block_leng= (int*) malloc(count*sizeof(int));
  displ=(int*) malloc(count*sizeof(int));

  for (i=0; i<output_nvar; i++){
    if (!(output_dump[i]==0)){  /* cioè devo scrivere la variabile */ 
     block_leng[k] = 1;
     displ[k] = i;
     k=k+1;
    }
  }
  
  errcode = MPI_Type_indexed(count,block_leng, displ, s->lsubarr, &dtype_lsub_arr);
  errcode = MPI_Type_commit(&dtype_lsub_arr); 
/*
  MPI_Type_get_extent(dtype_lsub_arr,lb,extent);
  printf("myid, %d, lb %d, extent %d of dtype_lsub_arr\n",myrank,lb,extent);
*/
/* DIAGNOSTICS */
#ifdef DEBUG
  if (myrank==0) {
    for (i=0; i<output_nvar; i++) printf("myid, %d, count %d, output_nvar %d, i %d, output_dump[i] %d, block_leng[i] %d, displ[i] %d\n", myrank, count, output_nvar, i, output_dump[i], block_leng[i], displ[i]); 
  }
#endif

  free(block_leng);
  free(displ);
  MPI_Barrier(s->comm);

  /* Setting of the new view. Each procs see all the file at the beginning of the writing */
  errcode = MPI_File_set_view(ifp, 0, MPI_BYTE, filetype_gsub_arr,
                    "native", MPI_INFO_NULL);
  MPI_Type_free(&filetype_gsub_arr);

/* DIAGNOSTICS */
#ifdef DEBUG
  int len;
  char es[MPI_MAX_ERROR_STRING];
  MPI_Error_string(errcode, es, &len);
  printf("myid %d, Errcode from MPI_File_set_view: %d | %s\n", myrank,  errcode, es);
#endif

  errcode = MPI_File_write_all_begin(ifp, va, 1,dtype_lsub_arr);
  MPI_Type_free(&dtype_lsub_arr);
    
/* DIAGNOSTICS */
#ifdef DEBUG
  printf("myid %d\n", myrank);
  MPI_Error_string(errcode, es, &len);
  printf("myid %d, Errcode from MPI_File_write_all_begin: %d | %s\n", myrank, errcode, es);
#endif

  return (int) AL_SUCCESS;
}

int AL_Write_array_end	(	void *	va,
		int	sz_ptr
	)

Completition of writing of a distributed array to a parallel file by using asynchronous MPI-IO

Parameters

[in]	buffer	pointer to the buffer to write
[in]	sz_ptr	integer pointer to the distributed array descriptor

Definition at line 133 of file al_write_array_async.c.

{
  char *a;
  SZ *s;

  MPI_Status status;

  MPI_File ifp;

  int errcode;

  int myrank;
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  a = (char *) va;

  s = sz_stack[sz_ptr];
  ifp = s->ifp;

  errcode=MPI_File_write_all_end(ifp, a, &status);

  /* DIAGNOSTICS */
#ifdef DEBUG
  int len;
  char es[128];
  if( errcode ){
    MPI_Error_string(errcode, es, &len);
    printf("Errcode from MPI_File_write_all_end: %d | %s\n", errcode, es);
  }
#endif

  MPI_File_sync(ifp);
   
  return (int) AL_SUCCESS;
}

int AL_Write_common	(	void *	,
		int	,
		AL_Datatype	,
		int
	)

int AL_Write_header	(	void *	,
		int	,
		AL_Datatype	,
		int
	)

Definition at line 285 of file al_io.c.

{
  char *buffer;
  int myrank;
  int nbytes, size;
  SZ *s;
  MPI_Status status;
  MPI_File ifp;


  MPI_Offset offset;
  MPI_Type_size(type, &size);
  buffer = (char *) vbuffer;

  nbytes = nelem*size;
  s      = sz_stack[sz_ptr];
  myrank = s->rank;

  ifp    = s->ifp;
  offset = s->io_offset;
  MPI_Barrier(s->comm);
  MPI_File_set_view(ifp, offset, MPI_BYTE, MPI_CHAR,
                    "native", MPI_INFO_NULL);
  if( myrank == 0 ){
/*    MPI_File_write(ifp, buffer, strlen(buffer), MPI_CHAR, &status);  */
    MPI_File_write(ifp, buffer, nelem, type, &status); 
  }

  s->io_offset += nbytes;


  return (int) AL_SUCCESS;
}

Here is the caller graph for this function: