FM / pstl

/usr/include/c++/11/pstl

Name	Size	Mode	Actions
algorithm_fwd.h	68340	0644	edit dl rm
algorithm_impl.h	174504	0644	edit dl rm
execution_defs.h	3694	0644	edit dl rm
execution_impl.h	4832	0644	edit dl rm
glue_algorithm_defs.h	32278	0644	edit dl rm
glue_algorithm_impl.h	64352	0644	edit dl rm
glue_execution_defs.h	1549	0644	edit dl rm
glue_memory_defs.h	3865	0644	edit dl rm
glue_memory_impl.h	19412	0644	edit dl rm
glue_numeric_defs.h	6620	0644	edit dl rm
glue_numeric_impl.h	12302	0644	edit dl rm
memory_impl.h	4045	0644	edit dl rm
numeric_fwd.h	7929	0644	edit dl rm
numeric_impl.h	18694	0644	edit dl rm
parallel_backend.h	845	0644	edit dl rm
parallel_backend_serial.h	4000	0644	edit dl rm
parallel_backend_tbb.h	43765	0644	edit dl rm
parallel_backend_utils.h	9111	0644	edit dl rm
parallel_impl.h	4110	0644	edit dl rm
pstl_config.h	7332	0644	edit dl rm
unseq_backend_simd.h	29182	0644	edit dl rm
utils.h	4606	0644	edit dl rm

Edit: /usr/include/c++/11/pstl/execution_impl.h (4832B)

#ifndef _PSTL_EXECUTION_IMPL_H
#define _PSTL_EXECUTION_IMPL_H

#include <iterator>
#include <type_traits>

#include "execution_defs.h"

namespace __pstl
{
namespace __internal
{

using namespace __pstl::execution;

/* predicate */

template <typename _Tp>
std::false_type __lazy_and(_Tp, std::false_type)
{
    return std::false_type{};
}

template <typename _Tp>
inline _Tp
__lazy_and(_Tp __a, std::true_type)
{
    return __a;
}

template <typename _Tp>
std::true_type __lazy_or(_Tp, std::true_type)
{
    return std::true_type{};
}

template <typename _Tp>
inline _Tp
__lazy_or(_Tp __a, std::false_type)
{
    return __a;
}

/* iterator */
template <typename _IteratorType, typename... _OtherIteratorTypes>
struct __is_random_access_iterator
{
    static constexpr bool value = __internal::__is_random_access_iterator<_IteratorType>::value &&
                                  __internal::__is_random_access_iterator<_OtherIteratorTypes...>::value;
    typedef std::integral_constant<bool, value> type;
};

template <typename _IteratorType>
struct __is_random_access_iterator<_IteratorType>
    : std::is_same<typename std::iterator_traits<_IteratorType>::iterator_category, std::random_access_iterator_tag>
{
};

/* policy */
template <typename _Policy>
struct __policy_traits
{
};

template <>
struct __policy_traits<sequenced_policy>
{
    typedef std::false_type allow_parallel;
    typedef std::false_type allow_unsequenced;
    typedef std::false_type allow_vector;
};

template <>
struct __policy_traits<unsequenced_policy>
{
    typedef std::false_type allow_parallel;
    typedef std::true_type allow_unsequenced;
    typedef std::true_type allow_vector;
};

template <>
struct __policy_traits<parallel_policy>
{
    typedef std::true_type allow_parallel;
    typedef std::false_type allow_unsequenced;
    typedef std::false_type allow_vector;
};

template <>
struct __policy_traits<parallel_unsequenced_policy>
{
    typedef std::true_type allow_parallel;
    typedef std::true_type allow_unsequenced;
    typedef std::true_type allow_vector;
};

template <typename _ExecutionPolicy>
using __collector_t =
    typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__collector_type;

template <typename _ExecutionPolicy>
using __allow_vector =
    typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_vector;

template <typename _ExecutionPolicy>
using __allow_unsequenced =
    typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_unsequenced;

template <typename _ExecutionPolicy>
using __allow_parallel =
    typename __internal::__policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_parallel;

template <typename _ExecutionPolicy, typename... _IteratorTypes>
auto
__is_vectorization_preferred(_ExecutionPolicy&& __exec)
    -> decltype(__internal::__lazy_and(__exec.__allow_vector(),
                                       typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()))
{
    return __internal::__lazy_and(__exec.__allow_vector(),
                                  typename __internal::__is_random_access_iterator<_IteratorTypes...>::type());
}

template <typename _ExecutionPolicy, typename... _IteratorTypes>
auto
__is_parallelization_preferred(_ExecutionPolicy&& __exec)
    -> decltype(__internal::__lazy_and(__exec.__allow_parallel(),
                                       typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()))
{
    return __internal::__lazy_and(__exec.__allow_parallel(),
                                  typename __internal::__is_random_access_iterator<_IteratorTypes...>::type());
}

template <typename policy, typename... _IteratorTypes>
struct __prefer_unsequenced_tag
{
    static constexpr bool value = __internal::__allow_unsequenced<policy>::value &&
                                  __internal::__is_random_access_iterator<_IteratorTypes...>::value;
    typedef std::integral_constant<bool, value> type;
};

template <typename policy, typename... _IteratorTypes>
struct __prefer_parallel_tag
{
    static constexpr bool value = __internal::__allow_parallel<policy>::value &&
                                  __internal::__is_random_access_iterator<_IteratorTypes...>::value;
    typedef std::integral_constant<bool, value> type;
};

} // namespace __internal
} // namespace __pstl

#endif /* _PSTL_EXECUTION_IMPL_H */

// -*- C++ -*- //===-- execution_impl.h --------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _PSTL_EXECUTION_IMPL_H #define _PSTL_EXECUTION_IMPL_H #include #include #include "execution_defs.h" namespace __pstl { namespace __internal { using namespace __pstl::execution; /* predicate */ template std::false_type __lazy_and(_Tp, std::false_type) { return std::false_type{}; } template inline _Tp __lazy_and(_Tp __a, std::true_type) { return __a; } template std::true_type __lazy_or(_Tp, std::true_type) { return std::true_type{}; } template inline _Tp __lazy_or(_Tp __a, std::false_type) { return __a; } /* iterator */ template struct __is_random_access_iterator { static constexpr bool value = __internal::__is_random_access_iterator<_IteratorType>::value && __internal::__is_random_access_iterator<_OtherIteratorTypes...>::value; typedef std::integral_constant type; }; template struct __is_random_access_iterator<_IteratorType> : std::is_same::iterator_category, std::random_access_iterator_tag> { }; /* policy */ template struct __policy_traits { }; template <> struct __policy_traits { typedef std::false_type allow_parallel; typedef std::false_type allow_unsequenced; typedef std::false_type allow_vector; }; template <> struct __policy_traits { typedef std::false_type allow_parallel; typedef std::true_type allow_unsequenced; typedef std::true_type allow_vector; }; template <> struct __policy_traits { typedef std::true_type allow_parallel; typedef std::false_type allow_unsequenced; typedef std::false_type allow_vector; }; template <> struct __policy_traits { typedef std::true_type allow_parallel; typedef std::true_type allow_unsequenced; typedef std::true_type allow_vector; }; template using __collector_t = typename __internal::__policy_traits::type>::__collector_type; template using __allow_vector = typename __internal::__policy_traits::type>::__allow_vector; template using __allow_unsequenced = typename __internal::__policy_traits::type>::__allow_unsequenced; template using __allow_parallel = typename __internal::__policy_traits::type>::__allow_parallel; template auto __is_vectorization_preferred(_ExecutionPolicy&& __exec) -> decltype(__internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) { return __internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); } template auto __is_parallelization_preferred(_ExecutionPolicy&& __exec) -> decltype(__internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) { return __internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); } template struct __prefer_unsequenced_tag { static constexpr bool value = __internal::__allow_unsequenced::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; typedef std::integral_constant type; }; template struct __prefer_parallel_tag { static constexpr bool value = __internal::__allow_parallel::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; typedef std::integral_constant type; }; } // namespace __internal } // namespace __pstl #endif /* _PSTL_EXECUTION_IMPL_H */