[Bug libstdc++/113807] New: [performance] bitset::set not using memset opportunity

[Bug libstdc++/113807] New: [performance] bitset::set not using memset opportunity

[rhalbersma at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

            Bug ID: 113807
           Summary: [performance] bitset::set not using memset opportunity
           Product: gcc
           Version: 14.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: rhalbersma at gmail dot com
  Target Milestone: ---

Conditionally on is_constant_evaluated() being false, bitset::reset delegate to
__builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)) and uses a loop otherwise. In
contrast, bitset::set unconditionally has a raw loop. 

Can't bitset::set also not similarly use __builtin_memset(_M_w, 0xFF, _Nw *
sizeof(_WordT)); when is_constant_evaluated() is false?

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2024-02-08
     Ever confirmed|0                           |1

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Yup, I don't see why not.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #2 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jonathan Wakely <redi@gcc.gnu.org>:

https://gcc.gnu.org/g:e7ae13a858f36031b8fd3aa07362752ff2b19b2e

commit r14-9002-ge7ae13a858f36031b8fd3aa07362752ff2b19b2e
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Thu Feb 8 15:46:08 2024 +0000

    libstdc++: Use memset to optimize std::bitset::set() [PR113807]

    As pointed out in the PR we already do this for reset().

    libstdc++-v3/ChangeLog:

            PR libstdc++/113807
            * include/std/bitset (bitset::set()): Use memset instead of a
            loop over the individual words.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[rhalbersma at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #3 from rhalbersma <rhalbersma at gmail dot com> ---
Nice that this is changed now. I noticed a similar optimization could be done
for bitset::operator== (more accurately: the helper _M_is_equal) where there is
an opportunity to use memcmp, with a similar dance for consteval contexts. MSVC
STL also does this.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |14.0

--- Comment #4 from Jonathan Wakely <redi at gcc dot gnu.org> ---
I'm surprised the compiler can't optimize _M_do_set() and operator== already,
but it looks like it doesn't recognize the trivial loops.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
For
unsigned int a[1024];

void
foo (void)
{
  for (int i = 0; i < 1024; ++i)
    a[i] = 0;
}

void
bar (void)
{
  for (int i = 0; i < 1024; ++i)
    a[i] = -1;
}
it certainly can.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #6 from Richard Biener <rguenth at gcc dot gnu.org> ---
It can also for an effective memset to a non-constant, but it has to be
uniform,
thus 'char'.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #7 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Hmm, yes, the code for bitset<N>::set() is actually similar to what we get for
foo() in comment 5. The new version with memset does produce different
(vectorized?) code though.

For operator== the current code is quite branchy, and looks better with memcmp
to me (but I don't really know what I'm talking about).

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[rhalbersma at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #8 from rhalbersma <rhalbersma at gmail dot com> ---
For bitset::operator==, I wonder why (at last in C++20 and later mode) it is
not defaulted? 

For bitset::set and bitset::operator==, I also wonder why the manual loop vs
memset/memcmp consteval logic is not delegated to a call of std::fill_n or
std::equal, respectively? Then std::bitset is better proofed against future
changes in the tradeoffs between manual loops, unrolled loops or library calls,
no?

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

--- Comment #9 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to rhalbersma from comment #8)
> For bitset::operator==, I wonder why (at last in C++20 and later mode) it is
> not defaulted?

Because nobody bothered to change working code.

> For bitset::set and bitset::operator==, I also wonder why the manual loop vs
> memset/memcmp consteval logic is not delegated to a call of std::fill_n or
> std::equal, respectively?

Those aren't constexpr in C++14, but bitset is. If we delegated to those algos
we'd still need a constexpr-in-C++14 manual loop.

[Bug libstdc++/113807] [performance] bitset::set not using memset opportunity

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113807

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|14.0                        |14.2

--- Comment #10 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 14.1 is being released, retargeting bugs to GCC 14.2.