transpose.h

#pragma once
 
#include <list>
#include <vector>
#include <memory>
#include <algorithm>
 
#include <stdio.h>
#ifdef _OPENMP
#include <omp.h>
#endif
 
#include "hptt_types.h"
 
namespace hptt {
 
   class Plan;
 
template<typename floatType>
class Transpose
{
 
   public:
                  
      /***************************************************
       * Cons, Decons, Copy, ...
       ***************************************************/
      Transpose( const int *sizeA, 
                 const int *perm, 
                 const int *outerSizeA, 
                 const int *outerSizeB, 
                 const int dim,
                 const floatType *A,
                 const floatType alpha,
                 floatType *B,
                 const floatType beta,
                 const SelectionMethod selectionMethod,
                 const int numThreads, 
                 const int *threadIds = nullptr,
                 const bool useRowMajor = false );
 
      Transpose(const Transpose &other);
 
      ~Transpose();
 
      /***************************************************
       * Getter & Setter
       ***************************************************/
      bool getConjA() noexcept { return conjA_; }
      void setConjA(bool conjA) noexcept { conjA_ = conjA; }
      int getNumThreads() const noexcept { return numThreads_; }
      void setNumThreads(int numThreads) noexcept { numThreads_ = numThreads; }
      floatType getAlpha() const noexcept { return alpha_; }
      floatType getBeta() const noexcept { return beta_; }
      void setAlpha(floatType alpha) noexcept { alpha_ = alpha; }
      void setBeta(floatType beta) noexcept { beta_ = beta; }
      void setInputPtr(const floatType *A) noexcept { A_ = A; }
      void setOutputPtr(floatType *B) noexcept { B_ = B; }
      const floatType* getInputPtr() const noexcept { return A_; }
      floatType* getOutputPtr() const noexcept { return B_; }
 
      void resetThreadIds() noexcept { threadIds_.clear(); }
 
      void setMaxAutotuningCandidates (int num) { maxAutotuningCandidates_ = num; } 
 
      void addThreadId(int threadId) noexcept { 
#ifdef _OPENMP
         omp_set_lock(&writelock);
         threadIds_.push_back(threadId); 
         std::sort(threadIds_.begin(), threadIds_.end()); 
         omp_unset_lock(&writelock);
#endif
      }
 
      void printThreadIds() const noexcept { for( auto id : threadIds_) printf("%d, ",id); printf("\n"); } 
      int getMasterThreadId() const noexcept { return threadIds_[0]; } 
 
      /***************************************************
       * Public Methods
       ***************************************************/
      void createPlan();
 
      template<bool useStreamingStores=true, bool spawnThreads=true, bool betaIsZero>
      void execute_expert() noexcept;
 
      void execute() noexcept;
 
      void print() noexcept;
 
   private:
      /***************************************************
       * Private Methods
       ***************************************************/
      void createPlans( std::vector<std::shared_ptr<Plan> > &plans ) const;
      std::shared_ptr<Plan> selectPlan( const std::vector<std::shared_ptr<Plan> > &plans );
      void fuseIndices();
      void skipIndices(const int *_sizeA, const int* _perm, const int *_outerSizeA, const int *_outerSizeB, const int dim);
      void computeLeadingDimensions();
      double loopCostHeuristic( const std::vector<int> &loopOrder ) const;
      double parallelismCostHeuristic( const std::vector<int> &loopOrder ) const;
      int getLocalThreadId(int myThreadId) const;
      template<bool spawnThreads>
      void getStartEnd(int n, int &myStart, int &myEnd) const;
      void setParallelStrategy(int id) noexcept { selectedParallelStrategyId_ = id; }
      void setLoopOrder(int id) noexcept { selectedLoopOrderId_ = id; }
 
      /***************************************************
       * Helper Methods
       ***************************************************/
      // parallelizes the loops by changing the value of parallelismStrategy
      void parallelize( std::vector<int> &parallelismStrategy,
                                        std::vector<int> &availableParallelismAtLoop, 
                                        int &totalTasks,
                                        std::list<int> &primeFactors, 
                                        const float minBalancing,
                                        const std::vector<int> &loopsAllowed) const;
      float getLoadBalance( const std::vector<int> &parallelismStrategy ) const;
      float estimateExecutionTime( const std::shared_ptr<Plan> plan); //execute just a few iterations and extrapolate the result
      void verifyParameter(const int *size, const int* perm, const int* outerSizeA, const int* outerSizeB, const int dim) const;
      void getBestParallelismStrategy ( std::vector<int> &bestParallelismStrategy ) const;
      void getBestLoopOrder( std::vector<int> &loopOrder ) const; //innermost loop idx is stored at dim_-1
      void getLoopOrders(std::vector<std::vector<int> > &loopOrders) const;
      void getParallelismStrategies(std::vector<std::vector<int> > &parallelismStrategies) const;
      void getAllParallelismStrategies( std::list<int> &primeFactorsToMatch, 
            std::vector<int> &availableParallelismAtLoop, 
            std::vector<int> &achievedParallelismAtLoop, 
            std::vector<std::vector<int> > &parallelismStrategies) const;
      void getAvailableParallelism( std::vector<int> &numTasksPerLoop ) const;
      int getIncrement( int loopIdx ) const;
      void executeEstimate(const Plan *plan) noexcept; // almost identical to execute, but it just executes few iterations and then extrapolates
      double getTimeLimit() const;
 
      const floatType* __restrict__ A_; 
      floatType* __restrict__ B_; 
      floatType alpha_; 
      floatType beta_; 
      int dim_; 
      std::vector<size_t> sizeA_; 
      std::vector<int> perm_; 
      std::vector<size_t> outerSizeA_; 
      std::vector<size_t> outerSizeB_;  
      std::vector<size_t> lda_;  
      std::vector<size_t> ldb_;  
      std::vector<int> threadIds_; 
      int numThreads_;
      int selectedParallelStrategyId_;
      int selectedLoopOrderId_;
      bool conjA_;
#ifdef _OPENMP
      omp_lock_t writelock;
#endif
 
      std::shared_ptr<Plan> masterPlan_; 
      SelectionMethod selectionMethod_;
      int maxAutotuningCandidates_;
      static constexpr int blocking_micro_ = REGISTER_BITS / 8 / sizeof(floatType);
      static constexpr int blocking_ = blocking_micro_ * 4;
 
      static constexpr int infoLevel_ = 0; // determines which auxiliary messages should be printed
};
 
 
extern template class Transpose<float>;
extern template class Transpose<double>;
extern template class Transpose<FloatComplex>;
extern template class Transpose<DoubleComplex>;
 
}