inline
unsigned int libMesh::default_grainsize()
{
  return libMeshPrivateData::_default_grainsize;
}

   * The grain size for the range.  The range will be subdivided into
   * subranges not to exceed the grain size.
   */
  std::size_t grainsize () const {return _grainsize;}

  /**
   * Set the grain size.

unsigned int num_pthreads(const Range & range,
                          unsigned int requested = libMesh::n_threads())
{
  std::size_t mn = std::min((std::size_t)requested, range.size()/range.grainsize());
  return mn > 0 ? cast_int<unsigned int>(mn) : 1;
}

  struct ProjectEdges : public SubProjector {
    ProjectEdges (GenericProjector & p) : SubProjector(p) {}

    ProjectEdges (ProjectEdges & p_e, Threads::split) : SubProjector(p_e.projector) {}

    using SubProjector::action;
    using SubProjector::f;

    }

    template <typename T2>
    void operator+= (T2 n)
    {
      _i += cast_int<T>(n);
    }

    template <typename T2>
    iterator operator+ (T2 n) const
    {
      iterator returnval(_i);
      returnval += n;
      return returnval;
    }

    bool operator== (const iterator & j) const

  {}

  // Signature needed for use in threads_pthread.h
  IntRange(const IntRange &,
           const const_iterator & begin,
           const const_iterator & end) :
    _begin(begin),
    _end(end)
  {}

  iterator begin() const { return _begin; }

  { return *_end - *_begin; }

  // For thread splitting control
  std::size_t grainsize () const { return libMesh::default_grainsize(); }

private:
  iterator _begin, _end;

  // The optimal minimum chunk size for threading is probably fairly
  // system-dependent.
  libMesh::libMeshPrivateData::_default_grainsize =
    libMesh::command_line_value("--default-grainsize",
                                libMesh::libMeshPrivateData::_default_grainsize);

  // Construct singletons who may be at risk of the

                      sender_could_become_owner)
                    {
                      if (it != repartitioned_node_pids.end() &&
                          pid < it->second)
                        it->second = pid;
                      else
                        repartitioned_node_pids[n] = pid;
                    }
                  else
                    if (it == repartitioned_node_pids.end())
                      repartitioned_node_pids[n] =
                        DofObject::invalid_processor_id;

                  repartitioned_node_sets_to_push[pid].insert(n);

                              if (neighbor->p_level() < my_p_level &&
                                  neighbor->p_refinement_flag() != Elem::REFINE)
                                {
                                  neighbor->set_p_refinement_flag(Elem::REFINE);
                                  level_one_satisfied = false;
                                  compatible_with_coarsening = false;
                                }
                              if (neighbor->p_level() == my_p_level &&

    TriChecker (Real ref_area, unsigned int verbosity) :
      my_returnval(), my_ref_area(ref_area),
      my_verbosity(verbosity) {}
    TriChecker (TriChecker & other, Threads::split) :
      my_returnval(), my_ref_area(other.my_ref_area),
      my_verbosity(other.my_verbosity) {}

    void operator()(const ConstElemRange & range) {

        }
    }

    void join(TriChecker & other) {
      my_returnval.merge(other.my_returnval);
    }
  };

  TriChecker checker (ref_area, this->_verbosity);

    LevelCounter () : nl(0) {}

    LevelCounter (LevelCounter &, Threads::split) :
      nl(0) {}

    void operator()(const ConstElemRange & range) {
      for (const Elem * elem : range)
        nl = std::max(elem->level() + 1, nl);
    }

    void join(const LevelCounter & other) {
      nl = std::max(nl, other.nl);
    }
  };

  LevelCounter counter;

              const NumericVector<T> & v2in) :
      v1(v1in), v2(v2in), norm_sq(0) {}

    L2Differ (L2Differ & other, Threads::split) :
      v1(other.v1), v2(other.v2), norm_sq(0) {}

    void operator()(const IntRange<numeric_index_type> & index_range) {
      for (const auto i : index_range)
        norm_sq += TensorTools::norm_sq(v1(i) - v2(i));
    }

    void join(const L2Differ & other) {
      norm_sq += other.norm_sq;
    }
  };

  L2Differ differ(*this, v);

              const NumericVector<T> & v2in) :
      v1(v1in), v2(v2in), norm(0) {}

    L1Differ (L1Differ & other, Threads::split) :
      v1(other.v1), v2(other.v2), norm(0) {}

    void operator()(const IntRange<numeric_index_type> & index_range) {
      for (const auto i : index_range)
        norm += libMesh::l1_norm_diff(v1(i), v2(i));
    }

    void join(const L1Differ & other) {
      norm += other.norm;
    }
  };

  L1Differ differ(*this, v);