It seems rather logical cause std::disjunction is supposed to avoid
instantiations but in case of:
std::disjunction<std::is_void<_Tp>, std::is_null_pointer<_Tp>>
you'll avoid std::is_null_pointer instantiation only for 'void' type and
at the price of instantiating std::disjunction so 2 instantiations at
best but most of the time 3, clearly useless here.
On 18/07/2023 08:24, Ken Matsui wrote:
Hi,
I took a benchmark for this.
https://github.com/ken-matsui/gcc-benches/blob/main/is_fundamental-disjunction.md#mon-jul-17-105937-pm-pdt-2023
template<typename _Tp>
struct is_fundamental
: public std::bool_constant<__is_arithmetic(_Tp)
|| std::is_void<_Tp>::value
|| std::is_null_pointer<_Tp>::value>
{ };
is faster than:
template<typename _Tp>
struct is_fundamental
: public std::bool_constant<__is_arithmetic(_Tp)
|| std::disjunction<std::is_void<_Tp>,
std::is_null_pointer<_Tp>
>::value>
{ };
Time: -32.2871%
Peak Memory: -18.5071%
Total Memory: -20.1991%
Sincerely,
Ken Matsui
On Sun, Jul 16, 2023 at 9:49 PM Ken Matsui <kmat...@cs.washington.edu> wrote:
On Sun, Jul 16, 2023 at 5:41 AM François Dumont <frs.dum...@gmail.com> wrote:
On 15/07/2023 06:55, Ken Matsui via Libstdc++ wrote:
This patch optimizes the performance of the is_fundamental trait by
dispatching to the new __is_arithmetic built-in trait.
libstdc++-v3/ChangeLog:
* include/std/type_traits (is_fundamental_v): Use __is_arithmetic
built-in trait.
(is_fundamental): Likewise. Optimize the original implementation.
Signed-off-by: Ken Matsui <kmat...@gcc.gnu.org>
---
libstdc++-v3/include/std/type_traits | 21 +++++++++++++++++----
1 file changed, 17 insertions(+), 4 deletions(-)
diff --git a/libstdc++-v3/include/std/type_traits
b/libstdc++-v3/include/std/type_traits
index 7ebbe04c77b..cf24de2fcac 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -668,11 +668,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
/// is_fundamental
+#if __has_builtin(__is_arithmetic)
+ template<typename _Tp>
+ struct is_fundamental
+ : public __bool_constant<__is_arithmetic(_Tp)
+ || is_void<_Tp>::value
+ || is_null_pointer<_Tp>::value>
+ { };
What about doing this ?
template<typename _Tp>
struct is_fundamental
: public __bool_constant<__is_arithmetic(_Tp)
|| __or_<is_void<_Tp>,
is_null_pointer<_Tp>>::value>
{ };
Based on your benches it seems that builtin __is_arithmetic is much better that
std::is_arithmetic. But __or_ could still avoid instantiation of
is_null_pointer.
Let me take a benchmark for this later.