Home
Publications
Presentations
Support
Download
Examples
Developers
Class Docs
Namespaces
Classes
Files
Mailing Lists
Gallery
Wiki

threads.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2012 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


#ifndef LIBMESH_THREADS_H
#define LIBMESH_THREADS_H

// Local includes
#include "libmesh/libmesh_config.h"
#include "libmesh/libmesh_common.h"  // for libmesh_assert

// Threading building blocks includes
#ifdef LIBMESH_HAVE_TBB_API
#  include "libmesh/libmesh_logging.h" // only mess with the perflog if we are really multithreaded
#  include "tbb/tbb_stddef.h"
#  include "tbb/blocked_range.h"
#  include "tbb/parallel_for.h"
#  include "tbb/parallel_reduce.h"
#  include "tbb/task_scheduler_init.h"
#  include "tbb/partitioner.h"
#  include "tbb/spin_mutex.h"
#  include "tbb/recursive_mutex.h"
#  include "tbb/atomic.h"
#endif

// C++ includes
#ifdef LIBMESH_HAVE_STD_THREAD
#  include <thread>
#elif LIBMESH_HAVE_TBB_CXX_THREAD
#  include "tbb/tbb_thread.h"
#endif



namespace libMesh
{


namespace Threads
{
  extern bool in_threads;

  class BoolAcquire {
  public:
    explicit
    BoolAcquire(bool& b) : _b(b) { libmesh_assert(!_b); _b = true; }

    ~BoolAcquire() { libmesh_assert(_b); _b = false; }
  private:
    bool& _b;
  };


#ifdef LIBMESH_HAVE_STD_THREAD
  //--------------------------------------------------------------------
  typedef std::thread Thread;

#elif LIBMESH_HAVE_TBB_CXX_THREAD
  //--------------------------------------------------------------------
  typedef tbb::tbb_thread Thread;
  
#else
  //--------------------------------------------------------------------
  class Thread
  {
  public:
    template <typename Callable>
    Thread (Callable f) { f(); }

    void join() {}

    bool joinable() const { return true; }
  };
  
#endif



#ifdef LIBMESH_HAVE_TBB_API
  //-------------------------------------------------------------------
  typedef tbb::task_scheduler_init task_scheduler_init;



  //-------------------------------------------------------------------
  typedef tbb::split split;



  //-------------------------------------------------------------------
  template <typename Range, typename Body>
  inline
  void parallel_for (const Range &range, const Body &body)
  {
    BoolAcquire b(in_threads);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    const bool logging_was_enabled = libMesh::perflog.logging_enabled();

    if (libMesh::n_threads() > 1)
      libMesh::perflog.disable_logging();
#endif

    if (libMesh::n_threads() > 1)
      tbb::parallel_for (range, body, tbb::auto_partitioner());

    else
      body(range);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    if (libMesh::n_threads() > 1 && logging_was_enabled)
      libMesh::perflog.enable_logging();
#endif
  }



  //-------------------------------------------------------------------
  template <typename Range, typename Body, typename Partitioner>
  inline
  void parallel_for (const Range &range, const Body &body, const Partitioner &partitioner)
  {
    BoolAcquire b(in_threads);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    const bool logging_was_enabled = libMesh::perflog.logging_enabled();

    if (libMesh::n_threads() > 1)
      libMesh::perflog.disable_logging();
#endif

    if (libMesh::n_threads() > 1)
      tbb::parallel_for (range, body, partitioner);

    else
      body(range);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    if (libMesh::n_threads() > 1 && logging_was_enabled)
      libMesh::perflog.enable_logging();
#endif
  }



  //-------------------------------------------------------------------
  template <typename Range, typename Body>
  inline
  void parallel_reduce (const Range &range, Body &body)
  {
    BoolAcquire b(in_threads);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    const bool logging_was_enabled = libMesh::perflog.logging_enabled();

    if (libMesh::n_threads() > 1)
      libMesh::perflog.disable_logging();
#endif

    if (libMesh::n_threads() > 1)
      tbb::parallel_reduce (range, body, tbb::auto_partitioner());

    else
      body(range);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    if (libMesh::n_threads() > 1 && logging_was_enabled)
      libMesh::perflog.enable_logging();
#endif
  }



  //-------------------------------------------------------------------
  template <typename Range, typename Body, typename Partitioner>
  inline
  void parallel_reduce (const Range &range, Body &body, const Partitioner &partitioner)
  {
    BoolAcquire b(in_threads);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    const bool logging_was_enabled = libMesh::perflog.logging_enabled();

    if (libMesh::n_threads() > 1)
      libMesh::perflog.disable_logging();
#endif

       if (libMesh::n_threads() > 1)
         tbb::parallel_reduce (range, body, partitioner);

       else
         body(range);

#ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING
    if (libMesh::n_threads() > 1 && logging_was_enabled)
      libMesh::perflog.enable_logging();
#endif
  }



  //-------------------------------------------------------------------
  typedef tbb::spin_mutex spin_mutex;

  //-------------------------------------------------------------------
  typedef tbb::recursive_mutex recursive_mutex;

  //-------------------------------------------------------------------
  template <typename T>
  class atomic : public tbb::atomic<T> {};



#else //LIBMESH_HAVE_TBB_API

  //-------------------------------------------------------------------
  class task_scheduler_init
  {
  public:
    static const int automatic = -1;
    explicit task_scheduler_init (int = automatic) {}
    void initialize (int = automatic) {}
    void terminate () {}
  };

  //-------------------------------------------------------------------
  class split {};

  //-------------------------------------------------------------------
  template <typename Range, typename Body>
  inline
  void parallel_for (const Range &range, const Body &body)
  {
    BoolAcquire b(in_threads);
    body(range);
  }

  //-------------------------------------------------------------------
  template <typename Range, typename Body, typename Partitioner>
  inline
  void parallel_for (const Range &range, const Body &body, const Partitioner &)
  {
    BoolAcquire b(in_threads);
    body(range);
  }

  //-------------------------------------------------------------------
  template <typename Range, typename Body>
  inline
  void parallel_reduce (const Range &range, Body &body)
  {
    BoolAcquire b(in_threads);
    body(range);
  }

  //-------------------------------------------------------------------
  template <typename Range, typename Body, typename Partitioner>
  inline
  void parallel_reduce (const Range &range, Body &body, const Partitioner &)
  {
    BoolAcquire b(in_threads);
    body(range);
  }

  //-------------------------------------------------------------------
  class spin_mutex
  {
  public:
    spin_mutex() {}
    void lock () {}
    void unlock () {}

    class scoped_lock
    {
    public:
      scoped_lock () {}
      explicit scoped_lock ( spin_mutex&  ) {}
      void acquire ( spin_mutex& ) {}
      void release () {}
    };
  };

  //-------------------------------------------------------------------
  class recursive_mutex
  {
  public:
    recursive_mutex() {}

    class scoped_lock
    {
    public:
      scoped_lock () {}
      explicit scoped_lock ( recursive_mutex&  ) {}
      void acquire ( recursive_mutex& ) {}
      void release () {}
    };
  };

  //-------------------------------------------------------------------
  template <typename T>
  class atomic
  {
  public:
    atomic () : _val(0) {}
    operator T& () { return _val; }
  private:
    T _val;
  };


#endif // #ifdef LIBMESH_HAVE_TBB_API



  template <typename T>
  class BlockedRange
  {
  public:
    typedef T const_iterator;

    explicit BlockedRange (const unsigned int new_grainsize = 1000) :
      _grainsize(new_grainsize)
    {}

    BlockedRange (const const_iterator first,
                  const const_iterator last,
                  const unsigned int new_grainsize = 1000) :
      _grainsize(new_grainsize)
    {
      this->reset(first, last);
    }

    BlockedRange (const BlockedRange<T> &r):
      _end(r._end),
      _begin(r._begin),
      _grainsize(r._grainsize)
    {}

    BlockedRange (BlockedRange<T> &r, Threads::split ) :
      _end(r._end),
      _begin(r._begin),
      _grainsize(r._grainsize)
    {
      const_iterator
        beginning = r._begin,
        ending    = r._end,
        middle    = beginning + (ending - beginning)/2u;

      r._end = _begin = middle;
    }

    void reset (const const_iterator first,
                const const_iterator last)
    {
      _begin = first;
      _end   = last;
    }

    const_iterator begin () const { return _begin; }

    const_iterator end () const { return _end; }

    unsigned int grainsize () const {return _grainsize;}

    void grainsize (const unsigned int &gs) {_grainsize = gs;}

    int size () const { return (_end -_begin); }

    //------------------------------------------------------------------------
    // Methods that implement Range concept
    //------------------------------------------------------------------------

    bool empty() const { return (_begin == _end); }

    bool is_divisible() const { return ((_begin + this->grainsize()) < _end); }

  private:

    const_iterator _end;
    const_iterator _begin;
    unsigned int _grainsize;
  };



  extern spin_mutex spin_mtx;

  extern recursive_mutex recursive_mtx;

} // namespace Threads

} // namespace libMesh

#endif // LIBMESH_THREADS_H

---

Site Created By: libMesh Developers
Last modified: February 05 2013 19:54:49 UTC

Hosted By: