parallel_reduce.h

Go to the documentation of this file.

#ifndef PARALLEL_REDUCE_H
#define PARALLEL_REDUCE_H

#include "parallel_common.h"

namespace parallel_ode
{

namespace ReduceTypes
{
  enum ReduceType { REDUCE_NONE,
                    REDUCE_SEQUENTIAL,
                    REDUCE_STRIDED,
                    REDUCE_COMPACT,
                    DEFAULT_REDUCE_TYPE = REDUCE_STRIDED };
}
typedef ReduceTypes::ReduceType ReduceType;


class ReduceStrategy
{
public:

  ReduceStrategy( )
      : bodyAlignment_( ParallelOptions::DEFAULTALIGN ),
      bodySize_( 0 ),
      bodySizeWithReduction_(0),
      bodyStride_(0),
      bodyOffsetStride_(0),
      bClearReduceBuffers_(true) { }

  virtual ~ReduceStrategy( ) { }

  virtual void initialize( int bodySize, int maxBodyRepetitionCount, const IntVector& batchRepetitionCount );

  virtual ReduceType getType( ) const { return ReduceTypes::REDUCE_NONE; }

  inline void setBodyAlignment( int bodyAlignment ) { bodyAlignment_ = bodyAlignment; }

  inline void setClearReduceBuffers( bool clearBuffers ) { bClearReduceBuffers_ = clearBuffers; }

  inline int getFinalIndex( int baseBodyIndex, int bodyOffset ) { return baseBodyIndex + (bodyOffset * bodyOffsetStride_); }

  inline int getBodyAlignment( ) const { return bodyAlignment_; }
  inline int getBodySize( ) const { return bodySize_; }
  inline int getBodySizeWithReduction( ) const { return bodySizeWithReduction_; }
  inline int getBodyStride( ) const { return bodyStride_; }
  inline int getBodyOffsetStride( ) const { return bodyOffsetStride_; }

  inline bool clearReduceBuffers( ) { return bClearReduceBuffers_; }

  inline void print( ) {
    printf("BSize,BSizeReduce,BStride,BOffsetStride = %d, %d, %d, %d\n", bodySize_, bodySizeWithReduction_, bodyStride_, bodyOffsetStride_);
  }

protected:
  inline void setBodySize( int bodySize ) { bodySize_ = bodySize; }
  inline void setBodySizeWithReduction( int bodySize ) { bodySizeWithReduction_ = bodySize; }
  inline void setBodyStride( int bodyStride ) { bodyStride_ = bodyStride; }
  inline void setBodyOffsetStride( int bodyStride ) { bodyOffsetStride_ = bodyStride; }

private:

  int bodyAlignment_;                   
  int bodySize_;                        
  int bodySizeWithReduction_;           
  int bodyStride_;                      
  int bodyOffsetStride_;                
  bool bClearReduceBuffers_;            
};


class SequentialReduceStrategy : public ReduceStrategy
{
public:

  SequentialReduceStrategy( ) : ReduceStrategy( ) { }
  virtual ~SequentialReduceStrategy( ) { }

  virtual void initialize( int bodySize, int maxBodyRepetitionCount, const IntVector& batchRepetitionCount );
  virtual ReduceType getType( ) const { return ReduceTypes::REDUCE_SEQUENTIAL; }
};


class StridedReduceStrategy : public ReduceStrategy
{

public:

  StridedReduceStrategy( ) : ReduceStrategy( ) { }
  virtual ~StridedReduceStrategy( ) { }

  virtual void initialize( int bodySize, int maxBodyRepetitionCount, const IntVector& batchRepetitionCount );
  virtual ReduceType getType( ) const { return ReduceTypes::REDUCE_STRIDED; }
};


class CompactReduceStrategy : public ReduceStrategy
{

public:

  CompactReduceStrategy( ) : ReduceStrategy( ) { }
  virtual ~CompactReduceStrategy( ) { }

  virtual void initialize( int bodySize, int maxBodyRepetitionCount, const IntVector& batchRepetitionCount );
  virtual ReduceType getType( ) const { return ReduceTypes::REDUCE_COMPACT; }
};


class ReduceStrategyFactory
{
public:
  static ReduceStrategy* create( ReduceType reduceType, bool bClearBuffers = true, int bodyAlignment = ParallelOptions::DEFAULTALIGN )
  {
    ReduceStrategy* newStrategy = NULL;

    switch( reduceType )
    {
      case ReduceTypes::REDUCE_SEQUENTIAL:
        newStrategy = new SequentialReduceStrategy( );
        break;
      case ReduceTypes::REDUCE_STRIDED:
        newStrategy = new StridedReduceStrategy( );
        break;
      case ReduceTypes::REDUCE_COMPACT:
        newStrategy = new CompactReduceStrategy( );
        break;
      case ReduceTypes::REDUCE_NONE:
      default:
        newStrategy = new ReduceStrategy( );
        break;
    }

    if( newStrategy ) {
      newStrategy->setBodyAlignment( bodyAlignment );
      newStrategy->setClearReduceBuffers( bClearBuffers );
    }

    return newStrategy;
  }
};

}

#endif