bsp_exptable.h

Go to the documentation of this file.

/*
    BSPonMPI. This is an implementation of the BSPlib standard on top of MPI
    Copyright (C) 2006  Wijnand J. Suijlen
                                                                                
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
                                                                                
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
                                                                                
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
                                                                                
    You may contact me via electronic mail:
      wjsuijle@users.sourceforge.net
    or snail mail:
      W.J. Suijlen
      Kraaiheidelaan 10
      2803 VP Gouda
      The Netherlands
*/
#ifndef BSP_EXPTABLE_H
#define BSP_EXPTABLE_H

#define ALIGNED_TYPE double

#define MAX(x,y)   ( ((x) > (y))?(x):(y))

#define MIN(x,y)   ( ((x) < (y))?(x):(y))

#include <stdlib.h>
#include <memory.h>
#include "bsp_alloc.h"

#ifdef UNITTESTING
  #include "../tests/bsp_test.h"
#else  
 #include <mpi.h>
#endif  

#include <config.h>

inline static int no_slots(const int bytes, const int slot_size)
{
  return (bytes + slot_size - 1) / slot_size;
}  

inline static unsigned int 
max(const unsigned int * restrict array, const int n, const int stride)
{
  int i;
  unsigned int result = 0;
  for (i = 0; i < n; i+=stride)
    result = MAX(array[i], result);
  return result  ;
}  
  

typedef char * MemRegElement;

typedef struct
{
  int numremov;             
  int * restrict removed;   
  int memoized_src_proc;   
  const MemRegElement * memoized_data_iter;
  const MemRegElement * memoized_end;
  int memoized_srccol;
} MemRegInfo;
typedef struct
{
  unsigned int * restrict data_sizes;
} ReqInfo;


typedef struct
{
  int size;
  int offset; 
  char *src;
  char *dst;  
} ReqElement;
typedef enum _ItemType
{ popreg, pushreg, put, get, send, settag } ItemType;

typedef struct
{
  char * dst;
} PutObject;

typedef struct
{
  unsigned int payload_size; 
} SendObject;

typedef struct
{
  const char *address;
} PushRegObject;

typedef struct
{
  const char *address;
} PopRegObject;

typedef struct
{
  int tag_size;
} SetTagObject;

union _DInfo 
  {
    PutObject put;
    SendObject send;
    PushRegObject push;
    PopRegObject pop;
    SetTagObject settag;
  } ;

typedef struct
{
  unsigned int size;  
  unsigned int next; 
  union _DInfo info; 
} DelivElement;
typedef struct
{
   unsigned int * * restrict start;

   unsigned int * * restrict count; 

    unsigned int * * restrict end;
} DelivInfo;

union SpecInfo
{
  MemRegInfo reg;
  DelivInfo deliv;
  ReqInfo   req;
};


typedef struct _ExpandableTable
{
  unsigned int nprocs;  
  unsigned int rows;    
  unsigned int * restrict used_slot_count;
  unsigned int slot_size;

  union SpecInfo info;
  
  char *data;
} ExpandableTable;


void
expandableTable_comm (const ExpandableTable * restrict send, 
                      ExpandableTable * restrict recv, MPI_Comm communicator );

/* intializes an ExpandableTable object
   @param table Reference to an ExpandableTable object
   @param nprocs Number of processors you have / columns you want to have
   @param rows Number of rows to allocate 
   @param elsize Slot size in bytes
   @param info Object specific info
*/   
static inline void
expandableTable_initialize (ExpandableTable * restrict table, 
                           const unsigned int nprocs, const unsigned int rows,
                           const int unsigned elsize, const union SpecInfo info)
{
  table->nprocs = nprocs;
  table->rows = rows;
  table->slot_size = elsize;
  table->info = info;
  table->data = bsp_malloc (nprocs * rows, elsize);

  table->used_slot_count = bsp_calloc (nprocs, sizeof (unsigned int));
}

static inline void
expandableTable_reset (ExpandableTable * restrict table)
{
  memset (table->used_slot_count, 0, sizeof (unsigned int) * table->nprocs);
}

static inline void
expandableTable_destruct (ExpandableTable * restrict table)
{
  bsp_free (table->data);
  bsp_free (table->used_slot_count);
}  

static inline void
expandableTable_expand (ExpandableTable * restrict table, const unsigned int rows,
                        const union SpecInfo newinfo)
{
  unsigned int newrows = rows + table->rows;
  char *newdata = 
    bsp_malloc( newrows * table->nprocs, table->slot_size);
  int i;

  for (i = 0; i < table->nprocs; i++)
    memcpy( newdata + i * newrows * table->slot_size, 
            table->data + i * table->rows * table->slot_size,
            table->used_slot_count[i] * table->slot_size);
   
  bsp_free(table->data);
  table->data = newdata;
  table->rows = newrows;
  table->info = newinfo;
}
static inline void
fixedElSizeTable_initialize (ExpandableTable * restrict table, const unsigned int nprocs, 
                             const unsigned int rows, const unsigned int elsize,
                             const union SpecInfo info)
{
  expandableTable_initialize (table, nprocs, rows, elsize, info);
}

static inline void 
fixedElSizeTable_push (ExpandableTable * restrict table, const unsigned int proc,
       void (*changeinfo) (union SpecInfo *restrict,  unsigned int, unsigned int), 
                       const void *restrict element)
{
  int j;

  /* add table if necessary */
  if (table->used_slot_count[proc] == table->rows)
    {
      union SpecInfo info = table->info;
      (*changeinfo) (&info, table->rows, 2*table->rows );
      expandableTable_expand (table, table->rows , info);
    }

  /* add pointer */
  j = table->used_slot_count[proc] + proc * table->rows;
  memcpy (table->data + j * table->slot_size, 
            element, table->slot_size);

  table->used_slot_count[proc] ++;
}
#endif

---