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 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;
}  

typedef struct
{
  int tag_size;   
  int slot_offset; 
  int inslot_offset;
  int n_mesg; 
  int n_mesg_deq;  
  int accum_size; 
} MesgQInfo;
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
{
} ReqInfo;
*/

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

typedef struct
{
  int item_count; 
  int item_size;  
} PutObject;

typedef struct
{
  int tag_size;  
  int payload_size; 
  int item_count;  
} SendObject;

typedef struct
{
  const char *address;
} PushRegObject;

typedef struct
{
  const char *address;
} PopRegObject;

typedef struct
{
  int tag_size;
} SetTagObject;

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

typedef struct
{
  int size;       
  ItemType type;  
  union _VarSzInfo info; 
  const char * restrict data; 
} VarSizeElement;
typedef struct
{
  VarSizeElement ** restrict latest_pushed_element;
} DelivInfo;

union SpecInfo
{
  MemRegInfo reg;
  DelivInfo deliv;
 /* ReqInfo req;*/
  MesgQInfo mesgq;
};


typedef struct _ExpandableTable
{
  int nprocs;   
  int rows;    
  int * restrict count;
  int * restrict used_slot_count;
  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 int nprocs,
                            const int rows, const int 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->count = bsp_calloc (nprocs, sizeof (int));
  table->used_slot_count = bsp_calloc (nprocs, sizeof (int));
}

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

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

static inline void
expandableTable_expand (ExpandableTable * restrict table, const int rows,
                        const union SpecInfo newinfo)
{
  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 int nprocs, const int rows,
                             const int elsize, const union SpecInfo info)
{
  expandableTable_initialize (table, nprocs, rows, elsize, info);
}

static inline void 
fixedElSizeTable_push (ExpandableTable * restrict table, const int proc,
                       void (*changeinfo) (union SpecInfo *restrict,  int, 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, 3*table->rows );
      expandableTable_expand (table, 2 * 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] ++;
  table->count[proc]++;
}

static inline void
varElSizeTable_initialize (ExpandableTable *restrict  table, const int nprocs,
                           const int rows, const union SpecInfo info) 
{
  expandableTable_initialize (table, nprocs, rows, sizeof (VarSizeElement), info);
}

static inline int
varElSizeTable_push (ExpandableTable *restrict  table, const int proc,
                     void (*changeinfo) (union SpecInfo *restrict , int,int ),
                     VarSizeElement elem)
{
  /* add table if necessary */
  const int tag_size = sizeof(VarSizeElement);
  const int object_size = no_slots(tag_size + elem.size, tag_size);
  int old_space = table->rows - table->used_slot_count[proc];
  VarSizeElement *pelem;

  if (object_size > old_space) 
    {
      union SpecInfo info = table->info;
      int space_needed = MAX(table->rows * 2, object_size - old_space);
      (*changeinfo)(&info, table->rows, space_needed + table->rows);
      expandableTable_expand(table, space_needed, info);
    }  
  
  pelem = (VarSizeElement *) table->data +
             table->used_slot_count[proc] + proc * table->rows;

  /* copy data */
  memcpy (pelem + 1, elem.data, elem.size);
  elem.data = NULL;             /* this pointer loses its meaning now */
  /* copy tag */
  *pelem = elem;
  /* increment counters */
  table->used_slot_count[proc] += object_size;
  table->count[proc]++;
  return 0;  
}
#endif

---