bsp_delivtable.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_DELIVTABLE_H
#define BSP_DELIVTABLE_H

#include "bsp_exptable.h"
#include <config.h>
void
deliveryTable_execute (ExpandableTable *restrict , ExpandableTable *restrict ,
                       ExpandableTable *restrict );

static inline void
deliveryTable_initialize (ExpandableTable * restrict table, const int nprocs, const int rows)
{
  union SpecInfo info;
  info.deliv.latest_pushed_element = 
    bsp_calloc(nprocs, sizeof(VarSizeElement *));
  varElSizeTable_initialize (table, nprocs, rows, info);
}

static inline void
deliveryTable_reset(ExpandableTable * restrict table)
{
  memset(table->info.deliv.latest_pushed_element, 0, 
      sizeof(VarSizeElement *) * table->nprocs);
  expandableTable_reset(table);
}  

static inline void
deliveryTable_destruct (ExpandableTable * restrict table)
{
  free(table->info.deliv.latest_pushed_element);
  expandableTable_destruct (table);
}

static inline void
deliveryTable_expand (ExpandableTable * restrict table, const int rows)
{
  union SpecInfo info = table->info;
  int offsets[table->nprocs], null[table->nprocs];
  int i;

  for (i = 0; i < table->nprocs; i++)
    {
      offsets[i] = info.deliv.latest_pushed_element[i] - table->rows * i -
                   (VarSizeElement *) table->data;
      null[i] = (info.deliv.latest_pushed_element[i] == NULL);
    }  
  expandableTable_expand (table, rows, info);

  for (i = 0; i < table->nprocs; i++)
    info.deliv.latest_pushed_element[i] =  null[i] ? NULL :
        (VarSizeElement *) table->data + table->rows * i + offsets[i];
  table->info = info;   
}

static void
delivInfoMake (union SpecInfo * restrict info , int b , int c)
{
}

static inline void
deliveryTable_push (ExpandableTable * restrict table, const int proc, const VarSizeElement elem)
{
  int offsets[table->nprocs], null[table->nprocs];
  int i;

  for (i = 0; i < table->nprocs; i++)
    {
      offsets[i] = (i==proc) ?
                      table->used_slot_count[i]
                     :
                      table->info.deliv.latest_pushed_element[i] - table->rows * i -
                        (VarSizeElement *) table->data;
                      
      null[i] = (table->info.deliv.latest_pushed_element[i] == NULL);
    } 
  varElSizeTable_push (table, proc, &delivInfoMake, elem);

  for (i = 0; i < table->nprocs; i++)
    {
      table->info.deliv.latest_pushed_element[i] = null[i] && i!=proc ? NULL : 
        (VarSizeElement *) table->data + i * table->rows + offsets[i];
    }   
 }

static inline void 
deliveryTable_pushSend(ExpandableTable * restrict table, const int proc, 
                       const void * restrict tag, const int tag_size,
                       const void * restrict payload, const int payload_size)
{
  /* add table if necessary */
  SendObject sendobj; VarSizeElement element;
  VarSizeElement * restrict latest_element = table->info.deliv.latest_pushed_element[proc];
  int free_space, used_space, object_size; // sizes in bytes!
  int old_element_slot_size, new_element_slot_size;
  char * restrict pointer;

  if (latest_element != NULL && 
      latest_element->type == send && 
      latest_element->info.send.payload_size == payload_size&&
      latest_element->info.send.tag_size == tag_size )
    {
      /* determine whether there is enough memory allocated and expand if
       * needed */
      object_size = tag_size + payload_size;
      used_space = 
        (table->used_slot_count[proc] - 1)*sizeof(VarSizeElement) + latest_element->size;
      free_space = table->rows * sizeof(VarSizeElement) - used_space; 

      if (object_size > free_space)
        {
          deliveryTable_expand(table, MAX(table->rows * 2, 1 + object_size / sizeof(VarSizeElement)));
          latest_element = table->info.deliv.latest_pushed_element[proc];
        }  

      /* set the pointer */
      pointer = 
        (char *) latest_element + sizeof(VarSizeElement) + 
        latest_element->info.send.item_count * (tag_size + payload_size);
          
      new_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + latest_element->size + object_size
                 , sizeof(VarSizeElement));
      old_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + latest_element->size
                 , sizeof(VarSizeElement));
      table->used_slot_count[proc] += new_element_slot_size - old_element_slot_size;
      //table->count doesn't change
      
      latest_element->size += object_size;
      latest_element->info.send.item_count++;
      // latest_element->info.send.payload_size && tag_size don't change
    }     
  else
    { /* else make a brand new VarSizeElement */
      sendobj.tag_size = tag_size; sendobj.payload_size = payload_size;
      sendobj.item_count = 1;
      element.size = tag_size + payload_size;
      element.type = send;
      element.info.send = sendobj;
      element.data = NULL;

      object_size = no_slots( sizeof(VarSizeElement) + element.size
                            , sizeof(VarSizeElement)); 
      free_space = table->rows - table->used_slot_count[proc];
 
      if (free_space < object_size)
         deliveryTable_expand(table, MAX(table->rows * 2, object_size ));

      pointer = (char *) 
        ( (VarSizeElement *) table->data + proc * table->rows + table->used_slot_count[proc]);
      table->info.deliv.latest_pushed_element[proc] = (VarSizeElement *) pointer;

      /* copy VarSizeElement */
      * (VarSizeElement *) pointer = element;
      pointer += sizeof(VarSizeElement);
      
      new_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + payload_size+tag_size
                 , sizeof(VarSizeElement));
      table->used_slot_count[proc] += new_element_slot_size;
      //table->count doesn't change

    }

  /* copy the tag */
  memcpy( pointer, tag, tag_size);
  pointer += tag_size;
  /* copy the payload */
  memcpy( pointer, payload, payload_size); 
}

static inline void 
deliveryTable_pushPut(ExpandableTable * restrict table, 
       const int proc, const void * const dst, 
       const void * const restrict data, const int size)
{
  VarSizeElement * restrict latest_element = table->info.deliv.latest_pushed_element[proc];
  int free_space, used_space, object_size; // sizes in bytes!
  int old_element_slot_size, new_element_slot_size;
  char * restrict pointer;

  if (latest_element != NULL && 
      latest_element->type == put && 
      latest_element->info.put.item_size == size)
    {
      /* determine whether there is enough memory allocated and expand if
       * needed */
      object_size = sizeof( void * ) + size;
      used_space = 
        (table->used_slot_count[proc] - 1)*sizeof(VarSizeElement) + latest_element->size;
      free_space = table->rows * sizeof(VarSizeElement) - used_space; 

      if (object_size > free_space)
        {
          deliveryTable_expand(table, MAX(table->rows * 2, 1 + object_size / sizeof(VarSizeElement)));
          latest_element = table->info.deliv.latest_pushed_element[proc];
        }  

      /* set the pointer */
      pointer = 
        (char *) latest_element + sizeof(VarSizeElement) + 
        latest_element->info.put.item_count *
          (latest_element->info.put.item_size + sizeof (void *));
          
      new_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + latest_element->size + object_size
                 , sizeof(VarSizeElement));
      old_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + latest_element->size
                 , sizeof(VarSizeElement));
      table->used_slot_count[proc] += new_element_slot_size - old_element_slot_size;
      //table->count doesn't change
      
      latest_element->size += object_size;
      latest_element->info.put.item_count++;
      // latest_element->info.put.item_size doesn't change
    }     
  else
    { /* else push a brand new VarSizeElement */
      PutObject putobj; 
      VarSizeElement element; 
      putobj.item_count = 1; putobj.item_size=size;
      element.size = size + sizeof(void *);
      element.type = put;
      element.info.put = putobj;
      element.data = NULL;
 
      free_space = table->rows - table->used_slot_count[proc];
      object_size = 
         no_slots(sizeof(VarSizeElement) + size, sizeof(VarSizeElement));       
      if (free_space < object_size)
         deliveryTable_expand(table, MAX(table->rows * 2, object_size ));

      pointer = (char *) 
        ( (VarSizeElement *) table->data + proc * table->rows + table->used_slot_count[proc]);
      table->info.deliv.latest_pushed_element[proc] = (VarSizeElement *) pointer;

      /* copy VarSizeElement */
      * (VarSizeElement *) pointer = element;
      pointer += sizeof(VarSizeElement);
      
      new_element_slot_size = 
         no_slots( sizeof(VarSizeElement) + size + sizeof(void *)
                 , sizeof(VarSizeElement));
      table->used_slot_count[proc] += new_element_slot_size;
      //table->count doesn't change

    }

  /* copy the destination */
  memcpy( pointer, &dst, sizeof(void const *));
  pointer += sizeof(void *);
  /* copy the data */
  memcpy( pointer, data, size); 
}


#endif

---