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 "bsp_mesgqueue.h"
#include <config.h>

void
deliveryTable_execute (ExpandableTable *restrict , ExpandableTable *restrict ,
                       MessageQueue *restrict, const int );

static inline void
deliveryTable_initialize (ExpandableTable * restrict table, const int nprocs, const int rows)
{
  union SpecInfo info;
  int p;
  const int index_size = 
    no_slots(3 * 6 * sizeof(unsigned int), sizeof(ALIGNED_TYPE));

  /* allocate memory */
  info.deliv.count = bsp_malloc( nprocs, sizeof(unsigned int *));
  info.deliv.start = bsp_malloc( nprocs, sizeof(unsigned int *));
  info.deliv.end = bsp_malloc(nprocs, sizeof(unsigned int *));
  expandableTable_initialize (table, nprocs, rows + index_size , sizeof(ALIGNED_TYPE), info);

  /* point the pointers to the correct places: the top each column */
  for (p = 0; p < nprocs; p++) 
     {
       table->info.deliv.start[p] = (unsigned int *)
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) ;
       table->info.deliv.count[p] = (unsigned int *) 
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) + 6 ;
       table->info.deliv.end[p] = (unsigned int *) 
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) + 12 ;

       memset((ALIGNED_TYPE *) table->data + p * table->rows , 0, sizeof(ALIGNED_TYPE) * index_size );
       /* don't overwrite this information */
       table->used_slot_count[p] = index_size;   
     }  
}

static inline void
deliveryTable_reset(ExpandableTable * restrict table)
{
  /* reset the index */
  int p;
  const int index_size = 
    no_slots(3 * 6 * sizeof(unsigned int), sizeof(ALIGNED_TYPE));

  expandableTable_reset(table);
  for (p = 0; p < table->nprocs; p++)
    {
      memset((ALIGNED_TYPE *) table->data + p * table->rows , 0, sizeof(ALIGNED_TYPE) * index_size );
      table->used_slot_count[p] = index_size;
    }  
 
}  

static inline void
deliveryTable_destruct (ExpandableTable * restrict table)
{
  bsp_free(table->info.deliv.start);
  bsp_free(table->info.deliv.count);
  bsp_free(table->info.deliv.end);
  expandableTable_destruct (table);
}

static inline void
deliveryTable_expand (ExpandableTable * restrict table, const int rows)
{
  int p;

  expandableTable_expand (table, rows, table->info);
  
  for (p = 0; p < table->nprocs; p++) 
     {
       table->info.deliv.start[p] = (unsigned int *)
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) ;
       table->info.deliv.count[p] = (unsigned int *) 
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) + 6 ;
       table->info.deliv.end[p] = (unsigned int *) 
         ((char *) table->data + p * table->rows * sizeof(ALIGNED_TYPE)) + 12 ;
     }  
}


static inline void *
deliveryTable_push (ExpandableTable *restrict  table, const int proc,
                     const DelivElement element, const ItemType type)
{
/* the percentages before a line refer to the costs of a line. These costs are
 * measured by the gnu profiler while running bspbench. This function is again
 * the most expensive function */
  const unsigned int slot_size = sizeof(ALIGNED_TYPE);
  const unsigned int tag_size = no_slots(sizeof(DelivElement), slot_size);
/* 1.05% */  const unsigned int object_size = tag_size + no_slots(element.size, slot_size);
  ALIGNED_TYPE * restrict pointer;
  
  int free_space = table->rows - table->used_slot_count[proc];

/* 1.57 */ if (object_size > free_space) 
    {
      int space_needed = MAX(table->rows, object_size - free_space);
      deliveryTable_expand(table, space_needed);
    }  
 
  /* manage deliveryTable info */
  if (table->info.deliv.count[proc][type] == 0)
/*1.84 */ table->info.deliv.start[proc][type] = table->used_slot_count[proc];
  else
    {
/* 2.62% */  pointer = (ALIGNED_TYPE *) table->data + table->info.deliv.end[proc][type] + proc * table->rows;
/* 5.25% */ ((DelivElement *) pointer)->next = table->used_slot_count[proc] - table->info.deliv.end[proc][type];
    }
 
/* 3.41% */  table->info.deliv.end[proc][type] = table->used_slot_count[proc];
/* 3.28% */  table->info.deliv.count[proc][type]++;
  
/* 6.56% */ pointer = (ALIGNED_TYPE *) table->data + table->used_slot_count[proc] + proc * table->rows;
/* 5.12% */  * (DelivElement *) pointer = element;
  pointer+=tag_size;
  /* increment counters */
/*4.99%*/  table->used_slot_count[proc] += object_size;

  return pointer ;  
}



#endif

---