parallel_array.h

Go to the documentation of this file.

#ifndef PARALLEL_ARRAY_H
#define PARALLEL_ARRAY_H

#include <parallel_common.h>
#include <parallel_memory.h>

#include <stdio.h>
#include <cstring>

namespace parallel_utils
{

namespace ArrayTypes
{
  enum ArrayType { HOST_ARRAY, DEVICE_ARRAY };
}
typedef ArrayTypes::ArrayType ArrayType;


#define BUFFER_MULTIPLIER 1.5              
#define BUFFER_MAX_THRESHOLD_MULTIPLIER .9 
#define BUFFER_MIN_THRESHOLD_MULTIPLIER .2 

template <typename Type, typename RType, ParallelType PType>
class ParallelArray
{
  typedef MemManager<Type,PType> PMemManager;
  typedef typename PMemManager::mem_flags MemFlags;

public:

  ParallelArray( ArrayType type = ArrayTypes::DEVICE_ARRAY, ArraySize size = 0, MemFlags flags = 0 )
      : type_(type), size_(size), internalSize_(0), flags_(flags), buffer_(NULL)
  {
    realloc( );
  }
  virtual ~ParallelArray()
  {
    dealloc( );
  }

  void setSize( ArraySize size )
  {
    if( size_ != size )
    {
      size_ = size;
      realloc();
    }
  }

  void setFlags( MemFlags flags )
  {
    if( flags_ != flags )
    {
      flags_ = flags;
      realloc();
    }
  }

  void print( const char* s, int stride = 1 ) const
  {
    printf("\n %s { ", s);
    for(ArraySize i = 0; i < getSize(); i += stride)
      printVal(buffer_[i]);
    printf("}\n");
  }

  inline void printVal(const int &a) const{ printf("%d ", a); }
  inline void printVal(const int4 &a) const { printf("(%d,%d,%d,%d) ", a.x, a.y, a.z, a.w); }
  inline void printVal(const float &a) const{ printf("%f ", a); }
  inline void printVal(const float3 &a) const { printf("(%f,%f,%f) ", a.x, a.y, a.z); }
  inline void printVal(const float4 &a) const { printf("(%f,%f,%f,%f) ", a.x, a.y, a.z, a.w); }
  inline void printVal(const double &a) const { printf("%f ", a); }
  inline void printVal(const double3 &a) const { printf("(%f,%f,%f) ", a.x, a.y, a.z); }
  inline void printVal(const double4 &a) const { printf("(%f,%f,%f,%f) ", a.x, a.y, a.z, a.w); }

  inline bool isHostArray( ) const { return type_ == ArrayTypes::HOST_ARRAY; }
  inline bool isDeviceArray( ) const { return type_ == ArrayTypes::DEVICE_ARRAY; }
  inline ArrayType getType( ) const { return type_; }
  inline ArraySize getByteSize( ) const { return getByteSize( size_ ); }
  inline ArraySize getByteSize( ArraySize arraySize ) const { return arraySize * sizeof(Type); }
  inline ArraySize getSize( ) const { return size_; }
  inline ArraySize getInternalSize( ) const { return internalSize_; }
  inline ArraySize getInternalByteSize( ) const { return getByteSize( internalSize_ ); }
  inline MemFlags getFlags( ) const { return flags_; }
  inline RType getBuffer( ) { return buffer_; }
  inline RType getBuffer( ArraySize offset ) { return offsetBuffer<RType>(buffer_, offset); }

protected:

  virtual void realloc( )
  {
    if( size_ < internalSize_ * BUFFER_MIN_THRESHOLD_MULTIPLIER ||
        size_ > internalSize_ * BUFFER_MAX_THRESHOLD_MULTIPLIER ) {
      dealloc();
      internalSize_ = size_ * BUFFER_MULTIPLIER;
      if( isHostArray() ) PMemManager::allocateHost((void**)&this->buffer_, getInternalByteSize(), flags_ );
      else PMemManager::allocateDevice( (typename PMemManager::device_init_type)&this->buffer_, getInternalByteSize() );
    }
  }

  virtual void dealloc( )
  {
    if( internalSize_ == 0 ) return;
    if( isHostArray() ) PMemManager::freeHost( this->buffer_ );
    else PMemManager::freeDevice( this->buffer_ );
    this->buffer_ = NULL;
  }

private:

  ArrayType type_;                      
  ArraySize size_;                      
  ArraySize internalSize_;              
  MemFlags flags_;                      
  RType buffer_;                        
};

template <class Type, ParallelType PType>
class ParallelHDArray
{
  typedef MemManager<Type,PType> PMemManager;
  typedef typename PMemManager::device_type DType;
  typedef typename PMemManager::host_type HType;
  typedef typename PMemManager::stream_type SType;
  typedef typename PMemManager::mem_flags MemFlags;

public:

  ParallelHDArray( ArraySize size = 0, MemFlags flags = 0, SType stream = 0)
      : stream_(stream), hostArray_( ArrayTypes::HOST_ARRAY, size, flags ), deviceArray_( ArrayTypes::DEVICE_ARRAY, size, flags )
  {
  }

  virtual ~ParallelHDArray()
  {
  }

  inline void syncToHost( ArraySize offset, ArraySize length, CopyType copyType = CopyTypes::COPY_DEFAULT )
  {
    if( getSize( ) <= 0 ) return;
    PMemManager::copyToHost( getHostBuffer( offset ), getDeviceBuffer( offset ), getByteSize( length ), copyType, stream_);
  }

  inline void syncToDevice( ArraySize offset, ArraySize length, CopyType copyType  = CopyTypes::COPY_DEFAULT )
  {
    if( getSize( ) <= 0 ) return;
    PMemManager::copyToDevice( getDeviceBuffer( offset ), getHostBuffer( offset ), getByteSize( length ), copyType, stream_);
  }

  inline void syncToHost( CopyType copyType = CopyTypes::COPY_DEFAULT ) { syncToHost(0, getSize(), copyType ); }

  inline void syncToDevice( CopyType copyType = CopyTypes::COPY_DEFAULT ) { syncToDevice(0, getSize(), copyType ); }

  void setSize( ArraySize size )
  {
    hostArray_.setSize( size );
    deviceArray_.setSize( size );
  }

  void setFlags( MemFlags flags )
  {
    hostArray_.setFlags( flags );
    deviceArray_.setFlags( flags );
  }

  void print( const char * s, int stride = 1 ) const  { hostArray_.print( s, stride ); }

  inline ArraySize getByteSize( ) const { return hostArray_.getByteSize(); }
  inline ArraySize getByteSize( ArraySize arraySize ) const { return hostArray_.getByteSize( arraySize ); }
  inline ArraySize getSize( ) const { return hostArray_.getSize(); }
  inline MemFlags getFlags( ) const { return hostArray_.getFlags(); }
  inline HType getHostBuffer( ) { return getHostBuffer( 0 ); }
  inline DType getDeviceBuffer( ) { return getDeviceBuffer( 0 ); }
  inline HType getHostBuffer( ArraySize offset ) { return hostArray_.getBuffer( offset ); }
  inline DType getDeviceBuffer( ArraySize offset ) { return deviceArray_.getBuffer( offset ); }

protected:

private:

  SType stream_;                                
  ParallelArray<Type,HType,PType> hostArray_;   
  ParallelArray<Type,DType,PType> deviceArray_; 
};

}

#endif