Attachment 279 Details for Bug 466 – Patch adding an initParallel() global function

This bugzilla service is closed. All entries have been migrated to https://gitlab.com/libeigen/eigen

[patch] Patch adding an initParallel() global function

multithreading.diff (text/plain), 6.05 KB, created by Gael Guennebaud on 2012-06-14 14:12:10 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Gael Guennebaud

Created: 2012-06-14 14:12:10 UTC

Size: 6.05 KB

patch

obsolete

>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 <http://www.gnu.org/licenses/>.
> 
> #ifndef EIGEN_GENERAL_BLOCK_PANEL_H
> #define EIGEN_GENERAL_BLOCK_PANEL_H
> 
> namespace Eigen { 
>-
>+  
> namespace internal {
> 
> template<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs=false, bool _ConjRhs=false>
> 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<typename Index> 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<Index>(1,size / 32);
> 
>   // 3 - compute the number of threads we are going to use
>   Index threads = std::min<Index>(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 <Eigen/Core>
>+
>+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.
>+
>+*/
>+
>+}

Actions: View | Diff

Attachments on bug 466: 279