parallel_array.h
Go to the documentation of this file.
00001 #ifndef PARALLEL_ARRAY_H
00002 #define PARALLEL_ARRAY_H
00003 
00004 #include <parallel_common.h>
00005 #include <parallel_memory.h>
00006 
00007 #include <stdio.h>
00008 #include <cstring>
00009 
00010 namespace parallel_utils
00011 {
00012 
00013 namespace ArrayTypes
00014 {
00016   enum ArrayType { HOST_ARRAY, DEVICE_ARRAY };
00017 }
00018 typedef ArrayTypes::ArrayType ArrayType;
00019 
00020 
00021 #define BUFFER_MULTIPLIER 1.5              
00022 #define BUFFER_MAX_THRESHOLD_MULTIPLIER .9 
00023 #define BUFFER_MIN_THRESHOLD_MULTIPLIER .2 
00025 
00026 template <typename Type, typename RType, ParallelType PType>
00027 class ParallelArray
00028 {
00029   typedef MemManager<Type,PType> PMemManager;
00030   typedef typename PMemManager::mem_flags MemFlags;
00031 
00032 public:
00033 
00041   ParallelArray( ArrayType type = ArrayTypes::DEVICE_ARRAY, ArraySize size = 0, MemFlags flags = 0 )
00042       : type_(type), size_(size), internalSize_(0), flags_(flags), buffer_(NULL)
00043   {
00044     realloc( );
00045   }
00046   virtual ~ParallelArray()
00050   {
00051     dealloc( );
00052   }
00053 
00059   void setSize( ArraySize size )
00060   {
00061     if( size_ != size )
00062     {
00063       size_ = size;
00064       realloc();
00065     }
00066   }
00067 
00073   void setFlags( MemFlags flags )
00074   {
00075     if( flags_ != flags )
00076     {
00077       flags_ = flags;
00078       realloc();
00079     }
00080   }
00081 
00088   void print( const char* s, int stride = 1 ) const
00089   {
00090     printf("\n %s { ", s);
00091     for(ArraySize i = 0; i < getSize(); i += stride)
00092       printVal(buffer_[i]);
00093     printf("}\n");
00094   }
00095 
00096   inline void printVal(const int &a) const{ printf("%d ", a); }
00097   inline void printVal(const int4 &a) const { printf("(%d,%d,%d,%d) ", a.x, a.y, a.z, a.w); }
00098   inline void printVal(const float &a) const{ printf("%f ", a); }
00099   inline void printVal(const float3 &a) const { printf("(%f,%f,%f) ", a.x, a.y, a.z); }
00100   inline void printVal(const float4 &a) const { printf("(%f,%f,%f,%f) ", a.x, a.y, a.z, a.w); }
00101   inline void printVal(const double &a) const { printf("%f ", a); }
00102   inline void printVal(const double3 &a) const { printf("(%f,%f,%f) ", a.x, a.y, a.z); }
00103   inline void printVal(const double4 &a) const { printf("(%f,%f,%f,%f) ", a.x, a.y, a.z, a.w); }
00104 
00105   inline bool isHostArray( ) const { return type_ == ArrayTypes::HOST_ARRAY; }
00106   inline bool isDeviceArray( ) const { return type_ == ArrayTypes::DEVICE_ARRAY; }
00107   inline ArrayType getType( ) const { return type_; }
00108   inline ArraySize getByteSize( ) const { return getByteSize( size_ ); }
00109   inline ArraySize getByteSize( ArraySize arraySize ) const { return arraySize * sizeof(Type); }
00110   inline ArraySize getSize( ) const { return size_; }
00111   inline ArraySize getInternalSize( ) const { return internalSize_; }
00112   inline ArraySize getInternalByteSize( ) const { return getByteSize( internalSize_ ); }
00113   inline MemFlags getFlags( ) const { return flags_; }
00114   inline RType getBuffer( ) { return buffer_; }
00115   inline RType getBuffer( ArraySize offset ) { return offsetBuffer<RType>(buffer_, offset); }
00116 
00117 protected:
00118 
00119   virtual void realloc( )
00120   {
00121     if( size_ < internalSize_ * BUFFER_MIN_THRESHOLD_MULTIPLIER ||
00122         size_ > internalSize_ * BUFFER_MAX_THRESHOLD_MULTIPLIER ) {
00123       dealloc();
00124       internalSize_ = size_ * BUFFER_MULTIPLIER;
00125       if( isHostArray() ) PMemManager::allocateHost((void**)&this->buffer_, getInternalByteSize(), flags_ );
00126       else PMemManager::allocateDevice( (typename PMemManager::device_init_type)&this->buffer_, getInternalByteSize() );
00127     }
00128   }
00129 
00130   virtual void dealloc( )
00131   {
00132     if( internalSize_ == 0 ) return;
00133     if( isHostArray() ) PMemManager::freeHost( this->buffer_ );
00134     else PMemManager::freeDevice( this->buffer_ );
00135     this->buffer_ = NULL;
00136   }
00137 
00138 private:
00139 
00140   ArrayType type_;                      
00141   ArraySize size_;                      
00142   ArraySize internalSize_;              
00143   MemFlags flags_;                      
00145   RType buffer_;                        
00147 };
00148 
00150 template <class Type, ParallelType PType>
00151 class ParallelHDArray
00152 {
00153   typedef MemManager<Type,PType> PMemManager;
00154   typedef typename PMemManager::device_type DType;
00155   typedef typename PMemManager::host_type HType;
00156   typedef typename PMemManager::stream_type SType;
00157   typedef typename PMemManager::mem_flags MemFlags;
00158 
00159 public:
00160 
00168   ParallelHDArray( ArraySize size = 0, MemFlags flags = 0, SType stream = 0)
00169       : stream_(stream), hostArray_( ArrayTypes::HOST_ARRAY, size, flags ), deviceArray_( ArrayTypes::DEVICE_ARRAY, size, flags )
00170   {
00171   }
00172 
00176   virtual ~ParallelHDArray()
00177   {
00178   }
00179 
00187   inline void syncToHost( ArraySize offset, ArraySize length, CopyType copyType = CopyTypes::COPY_DEFAULT )
00188   {
00189     if( getSize( ) <= 0 ) return;
00190     PMemManager::copyToHost( getHostBuffer( offset ), getDeviceBuffer( offset ), getByteSize( length ), copyType, stream_);
00191   }
00192 
00200   inline void syncToDevice( ArraySize offset, ArraySize length, CopyType copyType  = CopyTypes::COPY_DEFAULT )
00201   {
00202     if( getSize( ) <= 0 ) return;
00203     PMemManager::copyToDevice( getDeviceBuffer( offset ), getHostBuffer( offset ), getByteSize( length ), copyType, stream_);
00204   }
00205 
00211   inline void syncToHost( CopyType copyType = CopyTypes::COPY_DEFAULT ) { syncToHost(0, getSize(), copyType ); }
00212 
00218   inline void syncToDevice( CopyType copyType = CopyTypes::COPY_DEFAULT ) { syncToDevice(0, getSize(), copyType ); }
00219 
00225   void setSize( ArraySize size )
00226   {
00227     hostArray_.setSize( size );
00228     deviceArray_.setSize( size );
00229   }
00230 
00236   void setFlags( MemFlags flags )
00237   {
00238     hostArray_.setFlags( flags );
00239     deviceArray_.setFlags( flags );
00240   }
00241 
00248   void print( const char * s, int stride = 1 ) const  { hostArray_.print( s, stride ); }
00249 
00250   inline ArraySize getByteSize( ) const { return hostArray_.getByteSize(); }
00251   inline ArraySize getByteSize( ArraySize arraySize ) const { return hostArray_.getByteSize( arraySize ); }
00252   inline ArraySize getSize( ) const { return hostArray_.getSize(); }
00253   inline MemFlags getFlags( ) const { return hostArray_.getFlags(); }
00254   inline HType getHostBuffer( ) { return getHostBuffer( 0 ); }
00255   inline DType getDeviceBuffer( ) { return getDeviceBuffer( 0 ); }
00256   inline HType getHostBuffer( ArraySize offset ) { return hostArray_.getBuffer( offset ); }
00257   inline DType getDeviceBuffer( ArraySize offset ) { return deviceArray_.getBuffer( offset ); }
00258 
00259 protected:
00260 
00261 private:
00262 
00263   SType stream_;                                
00265   ParallelArray<Type,HType,PType> hostArray_;   
00266   ParallelArray<Type,DType,PType> deviceArray_; 
00268 };
00269 
00270 }
00271 
00272 #endif


parallel_quickstep
Author(s): Jared Duke
autogenerated on Wed Apr 23 2014 10:23:51