threads.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 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