matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>

#include <vector>
#include <map>

#ifdef SKEPU_OPENCL
#ifdef USE_MAC_OPENCL
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif
#include "src/device_mem_pointer_cl.h"
#endif



#ifdef SKEPU_CUDA
#include "src/device_mem_pointer_cu.h"
#include <cuda.h>
#endif

#include "skepu/src/malloc_allocator.h"
#include "skepu/src/environment.h"



namespace skepu
{

enum AccessType
{
   ROW_WISE, //C style iterating from rows
   COL_WISE // fortran style iterating from columns
};



template<typename T>
class Matrix
{

   // typedefs
public:

#ifdef SKEPU_CUDA
   typedef DeviceMemPointer_CU<T>* device_pointer_type_cu;
#endif

#ifdef SKEPU_OPENCL
   typedef DeviceMemPointer_CL<T>* device_pointer_type_cl;
#endif

#ifdef USE_PINNED_MEMORY
   typedef std::vector<T, malloc_allocator<T> > container_type;
   typedef typename std::vector<T, malloc_allocator<T> >::iterator vector_iterator;
   typedef typename std::vector<T, malloc_allocator<T> >::size_type size_type;
   typedef typename std::vector<T, malloc_allocator<T> >::value_type value_type;
   typedef typename std::vector<T, malloc_allocator<T> >::difference_type difference_type;
   typedef typename std::vector<T, malloc_allocator<T> >::pointer pointer;
   typedef typename std::vector<T, malloc_allocator<T> >::reference reference;
   typedef typename std::vector<T, malloc_allocator<T> >::const_reference const_reference;
   typedef typename std::vector<T, malloc_allocator<T> >::const_iterator const_iterator;
   typedef typename std::vector<T, malloc_allocator<T> >::const_reverse_iterator const_reverse_iterator;
#else
   typedef std::vector<T> container_type;
   typedef typename std::vector<T>::iterator vector_iterator;
   typedef typename std::vector<T>::size_type size_type;
   typedef typename std::vector<T>::value_type value_type;
   typedef typename std::vector<T>::difference_type difference_type;
   typedef typename std::vector<T>::pointer pointer;
   typedef typename std::vector<T>::reference reference;
   typedef typename std::vector<T>::const_reference const_reference;
   typedef typename std::vector<T>::const_iterator const_iterator;
   typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
#endif

public: //-- For Testing --//

   void setValidFlag(bool val)
   {
      m_valid = val;
   }
   
   T* GetArrayRep()
   {
      return &m_data[0];
   }

   friend std::ostream& operator<<(std::ostream &os, Matrix<T>& matrix)
   {
      matrix.updateHost();

      os << "Matrix: ("<< matrix.total_rows() <<" X "<<matrix.total_cols()<<")\n";
      for(size_type i=0; i<matrix.size(); i++)
      {
         os<<(matrix(i))<<" ";
         if((i+1)%(matrix.total_cols())==0)
            os << "\n";
      }
      os<<"\n";
      return os;
   }


   void randomize(int min = 0, int max = RAND_MAX)
   {
      invalidateDeviceData();

      for(size_type i = 0; i < size(); i++)
      {
         m_data.at(i) = (T)( rand() % (int)(max-min+1) + min);
         //            m_data.at(i) = min + (T)rand()/((T)RAND_MAX/(max-min));
      }
   }

   void save(const std::string& filename)
   {
      updateHost();

      std::ofstream file(filename.c_str());

      if (file.is_open())
      {
         for(size_type i = 0; i < m_data.size(); ++i)
         {
            file<<m_data.at(i) <<" ";
         }
         file.close();
      }
      else
      {
         std::cout<<"Unable to open file\n";
      }
   }

   void load(const std::string& filename, size_type rowWidth, size_type numRows = 0)
   {
      invalidateDeviceData();

      std::ifstream file(filename.c_str());

      if (file.is_open())
      {
         std::string line;
         getline (file,line);
         std::istringstream ss(line);
         T num;
         clear();

         //Load all elements
         if(numRows == 0)
         {
            while(ss >> num)
            {
               push_back(num);
            }
         }
         // Load only numElements elements
         else
         {
            for(size_type i = 0; i < (numRows*rowWidth); ++i)
            {
               ss >> num;
               push_back(num);
            }
         }

         m_cols = rowWidth;
         m_rows = (size()/rowWidth);

         file.close();
      }
      else
      {
         std::cout<<"Unable to open file\n";
      }
   }


// Constructors, destructors
public:

   ~Matrix()
   {
#ifdef SKEPU_OPENCL
      releaseDeviceAllocations_CL();
#endif

#ifdef SKEPU_CUDA
      releaseDeviceAllocations_CU();
#endif

      if(m_transpose_matrix)
         delete m_transpose_matrix;
   }


   Matrix(size_type _rows, size_type _cols): m_rows(_rows), m_cols(_cols), m_data(m_rows * m_cols), m_dataChanged(false), m_transpose_matrix(0), m_noValidDeviceCopy(true), m_valid(true)
   {
#ifdef SKEPU_OPENCL
      m_transposeKernels_CL = &(Environment<T>::getInstance()->m_transposeKernels_CL);
#endif
   }

   Matrix(size_type _rows, size_type _cols, const T& val): m_rows(_rows), m_cols(_cols),m_data(m_rows * m_cols, val), m_dataChanged(false), m_transpose_matrix(0), m_noValidDeviceCopy(true), m_valid(true)
   {
#ifdef SKEPU_OPENCL
      m_transposeKernels_CL = &(Environment<T>::getInstance()->m_transposeKernels_CL);
#endif
   }


   Matrix(const Matrix<T>& copy): m_noValidDeviceCopy(true), m_valid(true)
   {
      copy.updateHost();
      this->m_rows = copy.m_rows;
      this->m_cols = copy.m_cols;
      this->m_data= copy.m_data;
      this->m_transpose_matrix = copy.m_transpose_matrix;
      this->m_dataChanged = copy.m_dataChanged;
      
#ifdef SKEPU_OPENCL
      this->m_transposeKernels_CL = copy.m_transposeKernels_CL;
#endif
   }

private:
   Matrix(): m_rows(0), m_cols(0),m_data(), m_dataChanged(false), m_transpose_matrix(0), m_noValidDeviceCopy(true), m_valid(true)
   {}

public:

   size_type size() const
   {
      return m_data.size();
   }

   size_type total_rows() const
   {
      return m_rows;
   }

   size_type total_cols() const
   {
      return m_cols;
   }

   // highly dangerous, use with care.
   T *getAddress()
   {
      return &m_data[0];
   }

   void change_layout()
   {
      size_type tmp = m_rows;
      m_rows=m_cols;
      m_cols = tmp;

      if(m_transpose_matrix && m_transpose_matrix->total_rows()==m_cols && m_transpose_matrix->total_cols()==m_rows && !m_dataChanged)
         m_transpose_matrix->change_layout();
   }

private:
#ifdef SKEPU_CUDA
//    std::map<std::pair< int, std::pair< T*, size_type > >, device_pointer_type_cu > m_deviceMemPointers_CU;
   std::map<std::pair< T*, size_type >, device_pointer_type_cu > m_deviceMemPointers_CU[MAX_GPU_DEVICES];

   mutable std::map<std::pair< T*, size_type >, device_pointer_type_cu > m_deviceMemPointers_Modified_CU[MAX_GPU_DEVICES];
#endif

#ifdef SKEPU_OPENCL
   std::map<std::pair< cl_device_id, std::pair< T*, size_type > >, device_pointer_type_cl > m_deviceMemPointers_CL;
#endif

   size_type m_rows, m_cols;
   bool m_dataChanged;
   bool m_noValidDeviceCopy;


#ifdef USE_PINNED_MEMORY
   mutable std::vector<T, malloc_allocator<T> > m_data;
#else
   mutable std::vector<T> m_data;
#endif

   mutable bool m_valid; 
   // for col_iterator,
   mutable Matrix<T> *m_transpose_matrix;

   template<typename Type>
   void item_swap(Type &t1, Type &t2);


// External classes
public:
   class iterator;

   class proxy_elem;

public: //-- Operators --//

   void resize(size_type _rows, size_type _cols, T val = T());

   Matrix<T>& operator=(const Matrix<T>& other);
   Matrix<T>& operator=(const T& elem);

   bool operator==(const Matrix<T>& c1);
   bool operator!=(const Matrix<T>& c1);
   bool operator<(const Matrix<T>& c1);
   bool operator>(const Matrix<T>& c1);
   bool operator<=(const Matrix<T>& c1);
   bool operator>=(const Matrix<T>& c1);

   Matrix<T>& subsection(size_type row, size_type col, size_type rowWidth, size_type colWidth);

// #if SKEPU_DEBUG>0      
   std::string m_nameVerbose; // for debugging useful
// #endif   

public: //-- STL vector regular interface --//

   //Iterators
   iterator begin();
   const_iterator begin() const;
   iterator begin(unsigned row);
   const_iterator begin(unsigned row) const;

   iterator end();
   const_iterator end() const;
   iterator end(unsigned row);
   const_iterator end(unsigned row) const;

   //Capacity
   size_type capacity() const;

   void flush();
   bool empty() const;

   //Element access
   proxy_elem at(size_type row, size_type col);
   const T& at(size_type row, size_type col) const;

   size_type row_back(size_type row);
   const T& row_back(size_type row) const;

   size_type row_front(size_type row);
   const T& row_front(size_type row) const;

   proxy_elem col_back(size_type col);
   const T& col_back(size_type col) const;

   proxy_elem col_front(size_type col);
   const T& col_front(size_type col) const;

   void clear();

   iterator erase( iterator loc );
   iterator erase( iterator start, iterator end );

   void swap(Matrix<T>& from);

public: //-- Additions to interface --//

#ifdef SKEPU_OPENCL
   device_pointer_type_cl updateDevice_CL(T* start, size_type rows, size_type cols, Device_CL* device, bool copy);
   device_pointer_type_cl updateDevice_CL(T* start, size_type cols, Device_CL* device, bool copy);
   void flush_CL();
#endif

#ifdef SKEPU_CUDA
   void copyDataToAnInvalidDeviceCopy(DeviceMemPointer_CU<T> *copy, unsigned int deviceID, unsigned int streamID = 0);
   device_pointer_type_cu updateDevice_CU(T* start, size_type rows, size_type cols, unsigned int deviceID, unsigned int streamID, bool copy, bool writeAccess, bool usePitch, bool markOnlyLocalCopiesInvalid=false);
   device_pointer_type_cu updateDevice_CU(T* start, size_type cols, unsigned int deviceID, bool copy, bool writeAccess, bool markOnlyLocalCopiesInvalid=false, unsigned int streamID = 0);
   void flush_CU();

     bool isMatrixOnDevice_CU(int deviceID);        
   bool isModified_CU(unsigned int deviceID);
#endif

   // Care about device data
   const T& operator()(const size_type row, const size_type col) const;

   // Care about device data
   T& operator()(const size_type row, const size_type col);

   // Does not care about device data, use with care
   T& operator()(const size_type index);

   // Care about device data
   const T& operator[](const size_type index) const;

   // Care about device data
   T& operator[](const size_type index);




   void transpose_CPU();

#ifdef SKEPU_OPENMP
   void transpose_OMP();
#endif

#ifdef SKEPU_CUDA
   void transpose_CU(Device_CU *device);
#endif

#ifdef SKEPU_OPENCL
   void transpose_CL(unsigned int deviceID);
   std::vector<std::pair<cl_kernel, Device_CL*> > *m_transposeKernels_CL;
#endif

   // unary transpose operator
   inline Matrix<T>& operator~()
   {
      if(m_transpose_matrix && m_transpose_matrix->m_rows==m_cols && m_transpose_matrix->m_cols==m_rows && !m_dataChanged)
         return *m_transpose_matrix;

#if defined(SKEPU_CUDA)
      transpose_CU(Environment<int>::getInstance()->m_devices_CU.at(Environment<int>::getInstance()->bestCUDADevID));
#elif  defined(SKEPU_OPENCL)
      transpose_CL(0);
#elif defined(SKEPU_OPENMP)
      transpose_OMP();
#else
      transpose_CPU();
#endif

      m_dataChanged = false;

      return *m_transpose_matrix;
   }

   // To be able to explicitly force updates without flushing entire matrix.
   // Could be used with operator () above to avoid unneccesary function calls
   // due to implicit synch.

   void updateHost() const;
   void invalidateDeviceData();
   void updateHostAndInvalidateDevice();
   void releaseDeviceAllocations();
   void updateHostAndReleaseDeviceAllocations();


   const Matrix<T>& operator+=(const Matrix<T>& rhs);
   const Matrix<T>& operator+=(const T& rhs);

   const Matrix<T>& operator-=(const Matrix<T>& rhs);
   const Matrix<T>& operator-=(const T& rhs);

   const Matrix<T>& operator*=(const Matrix<T>& rhs);
   const Matrix<T>& operator*=(const T& rhs);

   const Matrix<T>& operator/=(const Matrix<T>& rhs);
   const Matrix<T>& operator/=(const T& rhs);

   const Matrix<T>& operator%=(const Matrix<T>& rhs);
   const Matrix<T>& operator%=(const T& rhs);

private:

#ifdef SKEPU_OPENCL
   void updateHost_CL() const;
   void invalidateDeviceData_CL();
   void releaseDeviceAllocations_CL();
#endif

#ifdef SKEPU_CUDA
   void updateHost_CU(int deviceID = -1) const;
   void invalidateDeviceData_CU(int deviceID = -1);
   void releaseDeviceAllocations_CU(int deviceID = -1);
#endif

}; // end class Matrix...


} // end namespace skepu

#include "src/matrix_iterator.inl"

#include "src/matrix_proxy.inl"
#include "src/matrix.inl"

#include "src/matrix_transpose.inl"


#ifdef SKEPU_OPENCL
#include "src/matrix_cl.inl"
#endif

#ifdef SKEPU_CUDA
#include "src/matrix_cu.inl"
#endif

#endif