diff --git a/Eigen/Core b/Eigen/Core --- a/Eigen/Core +++ b/Eigen/Core @@ -324,19 +324,19 @@ using std::ptrdiff_t; #include "src/Core/IO.h" #include "src/Core/Swap.h" #include "src/Core/CommaInitializer.h" #include "src/Core/Flagged.h" #include "src/Core/ProductBase.h" #include "src/Core/GeneralProduct.h" #include "src/Core/TriangularMatrix.h" #include "src/Core/SelfAdjointView.h" +#include "src/Core/products/GeneralBlockPanelKernel.h" #include "src/Core/products/Parallelizer.h" #include "src/Core/products/CoeffBasedProduct.h" -#include "src/Core/products/GeneralBlockPanelKernel.h" #include "src/Core/products/GeneralMatrixVector.h" #include "src/Core/products/GeneralMatrixMatrix.h" #include "src/Core/SolveTriangular.h" #include "src/Core/products/GeneralMatrixMatrixTriangular.h" #include "src/Core/products/SelfadjointMatrixVector.h" #include "src/Core/products/SelfadjointMatrixMatrix.h" #include "src/Core/products/SelfadjointProduct.h" #include "src/Core/products/SelfadjointRank2Update.h" diff --git a/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/Eigen/src/Core/products/GeneralBlockPanelKernel.h --- a/Eigen/src/Core/products/GeneralBlockPanelKernel.h +++ b/Eigen/src/Core/products/GeneralBlockPanelKernel.h @@ -21,17 +21,17 @@ // You should have received a copy of the GNU Lesser General Public // License and a copy of the GNU General Public License along with // Eigen. If not, see . #ifndef EIGEN_GENERAL_BLOCK_PANEL_H #define EIGEN_GENERAL_BLOCK_PANEL_H namespace Eigen { - + namespace internal { template class gebp_traits; /** \internal \returns b if a<=0, and returns a otherwise. */ inline std::ptrdiff_t manage_caching_sizes_helper(std::ptrdiff_t a, std::ptrdiff_t b) @@ -39,18 +39,17 @@ inline std::ptrdiff_t manage_caching_siz return a<=0 ? b : a; } /** \internal */ inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1=0, std::ptrdiff_t* l2=0) { static std::ptrdiff_t m_l1CacheSize = 0; static std::ptrdiff_t m_l2CacheSize = 0; - #pragma omp threadprivate(m_l1CacheSize,m_l2CacheSize) - if(m_l1CacheSize==0) + if(m_l2CacheSize==0) { m_l1CacheSize = manage_caching_sizes_helper(queryL1CacheSize(),8 * 1024); m_l2CacheSize = manage_caching_sizes_helper(queryTopLevelCacheSize(),1*1024*1024); } if(action==SetAction) { // set the cpu cache size and cache all block sizes from a global cache size in byte diff --git a/Eigen/src/Core/products/Parallelizer.h b/Eigen/src/Core/products/Parallelizer.h --- a/Eigen/src/Core/products/Parallelizer.h +++ b/Eigen/src/Core/products/Parallelizer.h @@ -52,32 +52,45 @@ inline void manage_multi_threading(Actio #endif } else { eigen_internal_assert(false); } } +} + +/** Must be call first when calling Eigen from multiple threads */ +inline void initParallel() +{ + int nbt; + internal::manage_multi_threading(GetAction, &nbt); + std::ptrdiff_t l1, l2; + internal::manage_caching_sizes(GetAction, &l1, &l2); +} + /** \returns the max number of threads reserved for Eigen * \sa setNbThreads */ inline int nbThreads() { int ret; - manage_multi_threading(GetAction, &ret); + internal::manage_multi_threading(GetAction, &ret); return ret; } /** Sets the max number of threads reserved for Eigen * \sa nbThreads */ inline void setNbThreads(int v) { - manage_multi_threading(SetAction, &v); + internal::manage_multi_threading(SetAction, &v); } +namespace internal { + template struct GemmParallelInfo { GemmParallelInfo() : sync(-1), users(0), rhs_start(0), rhs_length(0) {} int volatile sync; int volatile users; Index rhs_start; @@ -116,16 +129,17 @@ void parallelize_gemm(const Functor& fun Index max_threads = std::max(1,size / 32); // 3 - compute the number of threads we are going to use Index threads = std::min(nbThreads(), max_threads); if(threads==1) return func(0,rows, 0,cols); + Eigen::initParallel(); func.initParallelSession(); if(transpose) std::swap(rows,cols); Index blockCols = (cols / threads) & ~Index(0x3); Index blockRows = (rows / threads) & ~Index(0x7); diff --git a/doc/TopicMultithreading.dox b/doc/TopicMultithreading.dox new file mode 100644 --- /dev/null +++ b/doc/TopicMultithreading.dox @@ -0,0 +1,46 @@ +namespace Eigen { + +/** \page TopicMultiThreading Eigen and multi-threading + +\section TopicMultiThreading_MakingEigenMT Make Eigen run in parallel + +Some Eigen's algorithms can exploit the multiple cores present in your hardware. To this end, it is enough to enable OpenMP on your compiler, for instance: + * GCC: \c -fopenmp + * ICC: \c -openmp + * MSVC: check the respective option in the build properties. +You can control the number of thread that will be used using either the OpenMP API or Eiegn's API using the following priority: +\code + OMP_NUM_THREADS=n ./my_program + omp_set_num_threads(n); + Eigen::setNbThreads(n); +\endcode +Unless setNbThreads has been called, Eigen uses the number of threads specified by OpenMP. You can restore this bahavior by calling \code setNbThreads(0); \endcode +You can query the number of threads that will be used with: +\code +n = Eigen::nbThreads(n); +\endcode +You can disable Eigen's multi threading at compile time by defining the EIGEN_DONT_PARALLELIZE preprocessor token. + +Currently, the following algorithms can make use of multi-threading: + * general matrix - matrix products + * PartialPivLU + +\section TopicMultiThreading_UsingEigenWithMT Using Eigen in a multi-threaded application + +In the case your own application is multithreaded, and multiple threads make calls to Eigen, then you have to initialize Eigen by calling the following routine \b before creating the threads: +\code +#include + +int main(int argc, char** argv) +{ + Eigen::initParallel(); + + ... +} +\endcode + +In the case your application is parallelized with OpenMP, you might want to disable Eigen's own parallization as detailed in the previous section. + +*/ + +}