parallel_batch.h

Go to the documentation of this file.

#ifndef PARALLEL_BATCH_H
#define PARALLEL_BATCH_H

#include "parallel_common.h"

namespace parallel_ode
{

namespace BatchTypes
{
  enum BatchType { BATCH_RANDOM,
                   BATCH_GREEDY,
                   BATCH_COLORED,
                   DEFAULT_BATCH_TYPE = BATCH_RANDOM };
}
typedef BatchTypes::BatchType BatchType;


class BatchStrategy
{
public:

  typedef IntVector BatchVector;

  BatchStrategy( int maxBatches = ParallelOptions::MAXBATCHES )
      :  maxBatches_( maxBatches ),
         bAlign_( false ),
         alignment_( ParallelOptions::DEFAULTALIGN ) {

  }

  virtual ~BatchStrategy( ) { }

  virtual int batch( const int* pairList, const int numConstraints, const int numBodies,
                     BatchVector& constraintIndices,
                     BatchVector& bodyRepetitionCount0,
                     BatchVector& bodyRepetitionCount1,
                     BatchVector& maxBodyRepetitionCountInBatch,
                     BatchVector& batchIndices,
                     BatchVector& batchSizes );

  inline int getMaxBatches() const { return maxBatches_; }
  inline void setMaxBatches( int maxBatches ) { maxBatches_ = maxBatches_; }

  inline bool isAligning() const { return bAlign_; }
  inline void setAlign( bool bAlign ) { bAlign_ = bAlign; }

  inline int getAlignment() const { return alignment_; }
  inline void setAlignment( int alignment ) { alignment_ = alignment; }

protected:

  int baseBatch( const int* pairList,
                 const BatchVector& constraintIndices,
                 const BatchVector& batchSizes,
                 BatchVector& batchIndices,
                 BatchVector& bodyRepetitionCount0,
                 BatchVector& bodyRepetitionCount1,
                 BatchVector& maxBodyRepetitionCountInBatch );

  int batchRepetitionCount( const int* pairList,
                            const BatchVector& constraintIndices,
                            const BatchVector& batchIndices,
                            BatchVector& bodyRepetitionCount0,
                            BatchVector& bodyRepetitionCount1,
                            BatchVector& maxBodyRepetitionCountInBatch );

  static void batchIndicesFromBatchSizes( const BatchVector& batchSizes, BatchVector& batchIndices, bool bAlign, int alignment );

private:

  int maxBatches_;                      
  bool bAlign_;                         
  int alignment_;                       
};


//* A greedy batch strategy
class GreedyBatchStrategy : public BatchStrategy
{

public:

  GreedyBatchStrategy( int maxBatches = ParallelOptions::MAXBATCHES ) : BatchStrategy( maxBatches ) { }

  virtual int batch( const int* pairList, const int numPairs, const int numBodies,
                     BatchVector& bodyRepetitionCount0,
                     BatchVector& bodyRepetitionCount1,
                     BatchVector& maxBodyRepetitionCountInBatch,
                     BatchVector& constraintIndices,
                     BatchVector& batchIndices,
                     BatchVector& batchSizes );

};


//* A coloring batch strategy
class ColoringBatchStrategy : public BatchStrategy
{

public:

  ColoringBatchStrategy( int maxBatches =  ParallelOptions::MAXBATCHES ) : BatchStrategy( maxBatches ) { }

  virtual int batch( const int* pairList, const int numPairs, const int numBodies,
                     BatchVector& bodyRepetitionCount0,
                     BatchVector& bodyRepetitionCount1,
                     BatchVector& maxBodyRepetitionCountInBatch,
                     BatchVector& constraintIndices,
                     BatchVector& batchIndices,
                     BatchVector& batchSizes );

};


class BatchStrategyFactory
{
public:

  static BatchStrategy* create( BatchType batchType, int numBatches, bool bAlign = false, int alignment = ParallelOptions::DEFAULTALIGN )
  {
    BatchStrategy* newStrategy = NULL;
    switch(batchType)
    {
      case BatchTypes::BATCH_RANDOM:
        newStrategy = new BatchStrategy( numBatches );
        break;
      case BatchTypes::BATCH_GREEDY:
        newStrategy = new GreedyBatchStrategy( numBatches );
        break;
      case BatchTypes::BATCH_COLORED:
      default:
        newStrategy = new ColoringBatchStrategy( numBatches );
        break;
    }
    newStrategy->setAlign( bAlign );
    newStrategy->setAlignment( alignment );
    return newStrategy;
  }
};

}

#endif