threads.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2019 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
 
 
// Compile-time check: TBB and pthreads are now mutually exclusive.
#if defined(LIBMESH_HAVE_TBB_API) && defined(LIBMESH_HAVE_PTHREAD)
MULTIPLE THREADING MODELS CANNOT BE SIMULTANEOUSLY ACTIVE
#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_exceptionless_assert(_b); _b = false; }
private:
  bool & _b;
};
 
 
class NonConcurrentThread
{
public:
  template <typename Callable>
  NonConcurrentThread (Callable f) { f(); }
 
  void join() {}
 
  bool joinable() const { return true; }
};
 
} // namespace Threads
 
} // namespace libMesh
 
 
 
// Include thread-model specific algorithms and objects.  These
// headers include headers of their own and handle their own
// namespacing.
#define LIBMESH_SQUASH_HEADER_WARNING
#ifdef LIBMESH_HAVE_TBB_API
# include "libmesh/threads_tbb.h"
#elif LIBMESH_HAVE_PTHREAD
# include "libmesh/threads_pthread.h"
#else
# include "libmesh/threads_none.h"
#endif
 
 
 
namespace libMesh
{
 
namespace Threads
{
 
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