On Fri, 17 Feb 2023, 08:02 Alexandre Oliva via Libstdc++, < libstdc++@gcc.gnu.org> wrote: > On Feb 17, 2023, Alexandre Oliva wrote: > > > On vxworks, after destroying the semaphore used to implement a mutex, > > __gthread_mutex_lock fails and __gnu_cxx::__mutex::lock calls > > __throw_concurrence_lock_error. Nothing ensures the mutex_pool > > mutexes survive init-once objects containing _Safe_sequence_base. If > > such an object completes construction before mutex_pool > > initialization, it will be registered for atexit destruction after the > > mutex_pool mutexes, so the _M_detach_all() call in the > > _Safe_sequence_base dtor will use already-destructed mutexes, and > > basic_string/requirements/citerators_cc fails calling terminate. > > Here's an alternative approach, with zero runtime overhead. Negative > overhead, if you count the time it would have taken to destruct the > mutex pool :-) But it fails to destruct them, which is presumably of no > consequence. > Agreed, I was going to suggest we immortalise them like this. > [libstdc++] do not destruct mutex_pool mutexes > > [Copy of the paragraph quoted above omitted here] > > This patch fixes this problem by ensuring the mutex pool mutexes are > constructed on demand, on a statically-allocated buffer, but never > destructed. > > Regstrapped on x86_64-linux-gnu. > Tested on arm-vxworks7 (gcc-12) and arm-eabi (trunk). Ok to install? > OK, thanks. > for libstdc++-v3/ChangeLog > > * src/c++11/shared_ptr.cc (__gnu_internal::get_mutex): > Avoid destruction of the mutex pool. > --- > libstdc++-v3/src/c++11/shared_ptr.cc | 6 +++++- > 1 file changed, 5 insertions(+), 1 deletion(-) > > diff --git a/libstdc++-v3/src/c++11/shared_ptr.cc > b/libstdc++-v3/src/c++11/shared_ptr.cc > index bc70134359c87..74e879e582896 100644 > --- a/libstdc++-v3/src/c++11/shared_ptr.cc > +++ b/libstdc++-v3/src/c++11/shared_ptr.cc > @@ -36,7 +36,11 @@ namespace __gnu_internal _GLIBCXX_VISIBILITY(hidden) > { > // increase alignment to put each lock on a separate cache line > struct alignas(64) M : __gnu_cxx::__mutex { }; > - static M m[mask + 1]; > + // Use a static buffer, so that the mutexes are not destructed > + // before potential users (or at all) > + static __attribute__ ((aligned(__alignof__(M)))) > + char buffer[(sizeof (M)) * (mask + 1)]; > + static M *m = new (buffer) M[mask + 1]; > return m[i]; > } > } > > -- > Alexandre Oliva, happy hacker https://FSFLA.org/blogs/lxo/ > Free Software Activist GNU Toolchain Engineer > Disinformation flourishes because many people care deeply about injustice > but very few check the facts. Ask me about >