dist_list.tpp

Go to the documentation of this file.

/***
 * Copyright (c) 2005, SkeTo Project
 * All rights reserved.
 */
#ifndef __DIST_LIST_TPP__
#define __DIST_LIST_TPP__
#ifdef __SKETO_DEBUG__
#define debug(x) x
#else // __SKETO_DEBUG__
#define debug(x)
#endif // __SKETO_DEBUG__

//------------------------------------------------------------------------
// Access methods

template< typename A >
inline int
dist_list< A >::get_global_size( ) const
{
  return global_size;
}

template< typename A >
inline A&
dist_list< A >::at( int index )
{
  return data[ index ];
}

template< typename A >
inline const A&
dist_list< A >::at( int index ) const
{
  return data[ index ];
}

template< typename A >
inline int
dist_list< A >::get_begin_index( int rank ) const
{
  const int div = global_size / skeleton::procs;
  const int mod = global_size % skeleton::procs;
  if( rank <= mod ) {
    return ( div + 1 ) * rank;
  }
  else {
    return ( div + 1 ) * mod + div * ( rank - mod );
  }
}

template< typename A >
inline int
dist_list< A >::get_end_index( int rank ) const
{
  const int div = global_size / skeleton::procs;
  const int mod = global_size % skeleton::procs;
  if( rank < mod ) {
    return ( div + 1 ) * ( rank + 1 );
  }
  else {
    return ( div + 1 ) * mod + div * ( rank - mod + 1 );
  }
}

template< typename A >
inline int
dist_list< A >::get_local_size( int rank ) const
{
  if( global_size % skeleton::procs > rank ) {
    return ( global_size / skeleton::procs ) + 1;
  }
  else {
    return global_size / skeleton::procs;
  }
}

//------------------------------------------------------------------------
// Constructors

template< typename A >
inline
dist_list<A>::dist_list( int list_size_ )
  : global_size( list_size_ )
{
  this->init( );
}

template< typename A >
inline
dist_list<A>::dist_list( int array_size_,
             const A *array_ )
  : global_size( array_size_ )
{
  this->init( );

  if ( skeleton::rank == 0 ) {
    // for master process: local copy
    std::memcpy( data, array_, sizeof( A ) * local_size );
    
    // for the other processes
    for ( int dest = 1; dest < skeleton::procs; dest++ ) {
      MPI_Send( const_cast< A* >( &array_[ get_begin_index( dest ) ] ),
        get_local_size( dest ),
        mpitype, dest, TAG_DISTRIBUTE,
        MPI_COMM_WORLD );
    }
  }
  else {
    MPI_Status st;
    MPI_Recv( data, local_size, mpitype, 0, TAG_DISTRIBUTE, MPI_COMM_WORLD, &st );
  }
}

template< typename A> template< typename F >
inline
dist_list< A >::dist_list( const F &f,
               int list_size_ )
  : global_size( list_size_ )
{
  this->init( );

  for( int i = 0, index = begin; i < local_size; i++, index++ ){
    this->at( i ) = f( index );
  }
}

template< typename A >
inline
dist_list< A >::dist_list( const dist_list< A > &as )
  : global_size( as.global_size )
{
  this->init( );
  for ( int i = 0; i < local_size; i++ ) {
    this->at( i ) = as.at( i );
  }
}

template< typename A >
inline dist_list< A > &
dist_list< A >::operator=( const dist_list< A > &as )
{
  if ( this == &as ) return *this;

  if ( data ) delete[] data;
  this->global_size = as.global_size;
  this->init( );

  for ( int i = 0; i < local_size; i++ ) {
    this->at( i ) = as.at( i );
  }

  return *this;
}

template< typename A >
inline void
dist_list< A >::init( )
{
  MPI_Bcast( &global_size, 1, MPI_INT, 0, MPI_COMM_WORLD );
  begin = this->get_begin_index( skeleton::rank );
  end = this->get_end_index( skeleton::rank );
  local_size  = this->get_local_size( skeleton::rank );
  mpitype = template_mpitype< A >::type( );
  data  = new A[ local_size ];
}

//------------------------------------------------------------------------
// Destructor

template< typename A >
inline dist_list< A >::~dist_list( )
{
  delete[] data;
}

#endif // __DIST_LIST_TPP__

---