Implement syncstream (p0053)

[Mordante]

Summary

This patch implements std::basic_syncbuf and std::basic_osyncstream as specified in paper p0053r7. For ease of reviewing I am submitting this patch before submitting a patch for std::basic_osyncstream.

Please note, this patch is not 100% complete. I plan on adding more tests (see comments), specifically I plan on adding tests for multithreading and synchronization.

Edit: I decided that it would be far easier for me to keep track of this and make changes that affect both std::basic_syncbuf and std::basic_osyncstream if both were in one patch.

The patch was originally written by @zoecarver

Implements

• P0053R7 - C++ Synchronized Buffered Ostream
• LWG-3127 basic_osyncstream::rdbuf needs a const_cast
• LWG-3334 basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
• LWG-3570 basic_osyncstream::emit should be an unformatted output function
• LWG-3867 Should std::basic_osyncstream's move assignment operator be noexcept?

[mclow.lists]

libcxx/include/syncstream

103

Arrgh. Peter! Two functions with the same name, one returns bool the other void.
Not your problem, though.

[zoecarver]

• Updated mutex for gaurd_lock so that it corresponds to a streambuf.
• Added more thread tests.

[zoecarver]

• update/add to the tests

libcxx/include/syncstream

227

Nothing. If an exception is thrown from emit(), the destructor catches and ignores that exception.

318

I like the verbosity of saying == false. I'll update it, though.

[zoecarver]

• don't use not keyword

[mclow.lists]

libcxx/include/syncstream

202

As a static member variable - when does this get initialized? On first use? before main? Does it get initialized if the user never instantiates a basic_syncbuf?

209

Why unordered_map as opposed to map? Does std::hash< streambuf_type*> have some behavior that you want? [ Note: unordered_map might be the right choice. But you should say why it is the right choice somewhere. ]

280

This adds a default constructed mutex_ptr_type to the map if it doesn't already exist.
I suspect that's not what you wanted.

[mclow.lists]

libcxx/include/syncstream

221

How do entries get removed from __mtx_ptr_map?

[zoecarver]

libcxx/include/syncstream

209

The pointer specialization of std::hash should help with memory usage. Unordered map has a find complexity of O(1) which is the real reason I think it should be used. This stream should be CPU performant above all else, with hundreds of threads trying to access an element, I think the benefit of find speed outweighs the slight increase in memory consumption. Do you agree?

[mclow.lists]

libcxx/include/syncstream

209

The pointer specialization of std::hash should help with memory usage.

How?

Unordered map has a find complexity of O(1) which is the real reason I think it should be used.

Unordered map has a find complexity of O(1) in the best case. O(N) in the worst case. Which one this?

[zoecarver]

libcxx/include/syncstream

209

Unordered map has a find complexity of O(1) in the best case.

Sorry, yes, that is what I meant. I suspect that I will be closer to O(1) because there won't be very many elements.

I ran some basic benchmarks and came up with very similar results. std::unordered_map seems to be roughly 150ms slower (total time 16675ms vs 16521ms). Given this, I will update to use std::map to shrink the memory footprint.

[zoecarver]

libcxx/include/syncstream

202

Yes, because it is initialized out of line, it will be initialized any time this file is included.

I will update this to use an enum and get around the static data member initialization.

221

They don't. I don't think there is any way to say "will any threads ever need to access this streambuf again?"

If there was a way to only keep the streambuf in the static map while the object is active, I would be open to that. But, I am hesitant to do that because I want to keep the read/writes to the map as low as possible.

What would you suggest?

280

I can update this to use contains but, I don't think it matters much. There should never be a scenario where __mtx_ptr_map[__wrapped] doesn't exist. And if there is, then the below code will still pass because mutex_ptr_type == nullptr_t is OK.

[zoecarver]

• use contains
• use function level static
• use map instead of unordered_map

[zoecarver]

Add std::lock_guards to prevent races on the map. I ran with TSAN and got no warnings. I also increased the number of times I run the larger thread tests and now get no errors.

[zoecarver]

libcxx/include/syncstream

221

Given the "new" structure of __mtx_ptr_map, I think I can add a function to remove elements from the map safely. Would this be a good thing to add (the only reason it might not is for performance but, I think stale memory outweighs performance here)?

[zoecarver]

Ping @mclow.lists can you take another look at this?

[mclow.lists]

libcxx/include/syncstream

221

You could store a count, like shared_ptr does. How many sync streams are using this streambuf?

Increment the count on construction, decrement on destruction, remove at zero.

[Mordante]

libcxx/include/iosfwd

100

Can you comment these classes and typedefs have been added in C++20?

libcxx/include/syncstream

52

@mclow.lists Do you know whether these functions should be noexcept? There's a contraction in the standard
http://eel.is/c++draft/syncstream.syncbuf#assign

// [syncstream.syncbuf.assign], assignment and swap
 basic_syncbuf& operator=(basic_syncbuf&&);
 void swap(basic_syncbuf&);

http://eel.is/c++draft/syncstream.syncbuf#assign
basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
void swap(basic_syncbuf& other) noexcept;

The move constructor is not marked as noexcept and neither is emit so I assume [syncstream.syncbuf.assign] is wrong.

226

Minor nit __gaurd -> __guard.

230

Is it intended to use assert in a header?

238

Minor nit __gaurd -> __guard. Please grep for this typo, there's at least one more occurrence.

283

http://eel.is/c++draft/syncstream.syncbuf#assign-1 "Effects : Calls emit()..." I don't see that call.

[zoecarver]

libcxx/include/syncstream

52

See https://cplusplus.github.io/LWG/issue3498 I'm going to leave them as not-noexcept until we determine a resolution for this.

230

Fixed. Changed to a _LIBCPP_ASSERT

283

Good catch!

283

I wonder if the same goes for basic_osyncstream& operator=(basic_osyncstream&&) noexcept;. It seems like that operator just isn't specified at all... another LWG issue :P

[zoecarver]

libcxx/include/syncstream

52

Also, I just realized, the assignment operator 100% has to be noexcept because it calls emit which is designed to sometimes throw.

[zoecarver]

• Address review comments
• Switch back to unordered_map
• Replace shared_ptr with manual ref count

[zoecarver]

• Add comments
• Feature test macros
• Update www/status docs

[zoecarver]

Sorry for being so slow to update this patch. I think all review comments have been addressed, and this is now ready for re-review.

cc @ldionne and @mclow.lists.

[• joe.sylve]

libcxx/include/syncstream

289

This move constructor will lose the existing buffered contents. Is this intended? I'd expect that the __str buffer would also be moved and the base class's pointers adjusted.

[Mordante]

Rebased, updated coding style. fix tests.

Note I still need to do a review of the patch and address the open review comments.
Mainly a test to see the status of the CI.

[Mordante]

CI fixes.

[Mordante]

libcxx/include/syncstream

221

I implemented this part and indeed use a count to. Not cleaning up sound like a memory leak which might affect long running applications that create a lot syncbufs.

289

This comment seems no longer be attached to its original location so not sure what you're referring to. I have noticed several issues with the move assignment and constructor.

[Mordante]

Rebased and lots of improvements

• fixed CI issues
• fixed modules
• added nonmember swap
• fixed member swap signature
• changed implementation for the mutex addresses a review comment

• Added more tests to validate the class, manual review found several issues in the overflow function and move operations
• Testing found more issues, for example in emit
• Removed a non-needed class member for flusing

Implemented 3 LWG issues

• 3334. basic_osyncstream move assignment and destruction calls basic_syncbuf::emit() twice
• 3867. Should std::basic_osyncstream's move assignment operator be noexcept?
• 3570. basic_osyncstream::emit should be an unformatted output function

Marked one LWG as done

• 3127. basic_osyncstream::rdbuf needs a const_cast

[Mordante]

Tab -> space

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

libcxx/include/syncstream

207

It *might* be possible to use a bit in the locale to implement a lock for all streambufs. Something like

diff --git a/libcxx/include/__locale b/libcxx/include/__locale
index ccac748c44e4..4942808ac2bc 100644
--- a/libcxx/include/__locale
+++ b/libcxx/include/__locale
@@ -131,9 +131,11 @@ private:
     static locale& __global();
     bool has_facet(id&) const;
     const facet* use_facet(id&) const;
+};
 
-    template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
-    template <class _Facet> friend const _Facet& use_facet(const locale&);
+template <>
+struct __free_bit_traits<locale> {
+    // expose the free bit in `__imp*`
 };
 
 class _LIBCPP_EXPORTED_FROM_ABI locale::facet
diff --git a/libcxx/include/streambuf b/libcxx/include/streambuf
index 095ac7d3ad83..b42fae608a5a 100644
--- a/libcxx/include/streambuf
+++ b/libcxx/include/streambuf
@@ -296,7 +296,9 @@ protected:
     virtual int_type overflow(int_type __c = traits_type::eof());
 
 private:
-    locale __loc_;
+    static_assert(__has_free_bits<locale>);
+    __free_bit_pair<locale, 1> __loc_;
+    // Now implement a lock using that single free bit.
     char_type* __binp_;
     char_type* __ninp_;
     char_type* __einp_;
diff --git a/libcxx/src/locale.cpp b/libcxx/src/locale.cpp
index 59c7ce4d43d6..ade1aa688c4d 100644
--- a/libcxx/src/locale.cpp
+++ b/libcxx/src/locale.cpp
@@ -543,7 +543,7 @@ locale::__imp::make_classic()
     // only one thread can get in here and it only gets in once
     static aligned_storage<sizeof(locale)>::type buf;
     locale* c = reinterpret_cast<locale*>(&buf);
-    c->__locale_ = &make<__imp>(1u);
+    c->__get_locale() = &make<__imp>(1u);
     return *c;
 }

Do you know what other implementations have done? Have they gone through the trouble of finding a lock inside streambufs or do they use a global map?

387

Do we take advantage of what std::string provides (i.e. growth characteristics, SBO, etc..). If we do take advantage of those, then it might be worth using std::string, otherwise I think we might as well use a character buffer we manually manage to save on the duplication of begin/end information.

[Mordante]

libcxx/include/syncstream

207

They use "global" maps. As discussed I think it makes more sense not to do this and mark the feature as experimental. Then investigate whether this alternative approach is worth the hassle. I still think we should finish it before LLVM 18.

387

No basically the SBO is "killed" by "str_.resize(str_.capacity() + 1);" This could be smarter and keep the SBO. I'm not sure how useful SBO is. It only helps if all data flushed fits in the SBO area.

[Mordante]

Addresses review comments and updates tests.

[ldionne]

Thanks a lot for picking up this patch! I have a bunch of comments but this is starting to look pretty good.

libcxx/include/map

1702–1703 ↗

(On Diff #557562)

Can you file a Github issue and link it here? In the issue you can say something like "we have a potential use-after-move in map::operator[]" and link to https://godbolt.org/z/e1x9c1h6Y.

libcxx/include/syncstream

158

This seems to be a generic utility to lock addresses. We could extract it from <syncstream> and make it generic, and then reuse it from here in <syncstream>. That way we could potentially reuse this code if we have a need for it in the future.

Or we could also maybe even abstract away the fact that we're containing a mutex inside the value_type. Then this would be a generic map from addresses to some payload.

191

operator[] or .find() maybe? Note that operator[] has an unfortunate precedent of default-constructing the key if it's not present in std::map so we might want to be careful about re-using operator[], but this is worth thinking about.

199

If this class represents a by-address lock, perhaps this should be bool __is_locked(void* __ptr).

207

I think this usage of a function-local static is quite interesting. It's really important to have exactly one instance of this object in the program, otherwise the locking won't work as intended. However, I think it is possible to end up with multiple copies of that object right now:

1. If we have two TUs that use different versions of libc++, I think we could end up with e.g. __wrapped_streambuf_mutex::__instance[v1800]::__result and __wrapped_streambuf_mutex::__instance[v1900]::__result.
2. On GCC where we use always_inline, I think this might also end up generating multiple function-local statics but I am not certain about that. The function-local static itself might be linkonce_odr and deduplicated across TUs correctly.

I wonder whether we should instead be stuffing that into the dylib -- that would definitely remove any ambiguity about there being multiple copies of the object. And if we do that, we could also hide the implementation behind a pimpl-like idiom, that way

• we do not have to depend on std::map in syncstream
• we can change to another implementation (e.g. std::flat_map) in the future without impacting our ABI

Concretely, since this is pretty heavyweight anyway, I don't think that we gain much by having these methods defined in headers in the hopes that Clang would inline stuff better.

239

442–445

I think these can be removed since they are in iosfwd already.

525–528

Same, can be removed!

libcxx/test/std/input.output/syncstream/osyncstream/members/get_wrapped.pass.cpp

1 ↗

(On Diff #557562)

Are we missing a test for rdbuf?

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.move.pass.cpp

17 ↗

(On Diff #557562)

36 ↗

(On Diff #557562)

Let's add a test for noexcept-ness since the current WP clearly specifies it, but we might remove it in the future.

54 ↗

(On Diff #557562)

This tests for implicit-ness too. IMO using std::move here instead of a temporary makes the test clearer, but this is equivalent so your choice.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.allocator.pass.cpp

34 ↗

(On Diff #557562)

const?

42 ↗

(On Diff #557562)

For explicit.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.ostream.pass.cpp

34 ↗

(On Diff #557562)

Reversed arguments.

libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp

19–20

Can you replace this by a short comment explaining what this tests?

libcxx/test/std/input.output/syncstream/osyncstream/types.compile.pass.cpp

38–39 ↗

(On Diff #557562)

Remove?

libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp

2

I think this is now tested in cons.pointer.allocator.pass.cpp and cons.move.pass.cpp?

libcxx/test/std/input.output/syncstream/syncbuf/sputc.pass.cpp

148 ↗

(On Diff #557562)

return 0!

libcxx/test/std/input.output/syncstream/syncbuf/sputn.pass.cpp

131 ↗

(On Diff #557562)

return 0

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.assign/assign.pass.cpp

17 ↗

(On Diff #557562)

We don't seem to be testing that this is noexcept, and also I don't think we test the return type + return value of the function (with the usual same_as<basic_syncbuf&> decltype(auto) ret = (assignment); assert(&ret == &obj);).

71–72 ↗

(On Diff #557562)

105 ↗

(On Diff #557562)

I think this is a copy-paste, you probably don't need to check this again here. Probably same thing below?

107 ↗

(On Diff #557562)

Duplicated too. Below as well?

231 ↗

(On Diff #557562)

Generally speaking, I find it useful to add a short plain english comment explaining these test cases, since what's being tested may not be easy to figure out a few years down the line. I also wouldn't mind if these were defined inline inside test() w/ the comments.

258 ↗

(On Diff #557562)

287 ↗

(On Diff #557562)

etc..

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/cons.pointer.allocator.pass.cpp

31 ↗

(On Diff #557562)

We should make this std::allocator<CharT> const alloc; (below too), that way the test would fail if the constructor were declared as basic_syncbuf(streambuf_type* obuf, Allocator&);, which would pass right now.

33 ↗

(On Diff #557562)

Here and below, we should use Buf buf = {nullptr, alloc} to test that this is an implicit constructor.

39–41 ↗

(On Diff #557562)

We could change those to

#ifndef TEST_HAS_NO_THREADS
  LIBCPP_ASSERT(...);
#endif

Non-blocking, just a suggestion if you like that better.

43 ↗

(On Diff #557562)

So here IIUC, the following would be equally valid:

std::basic_stringbuf<CharT> w;
Buf buf = {&w, alloc};

IMO not reusing basic_syncbuf here would make the test clearer.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/cons.pointer.pass.cpp

32 ↗

(On Diff #557562)

I think what you want here is

static_assert(!std::convertible_to<std::basic_streambuf<CharT>*, Buf>);

41 ↗

(On Diff #557562)

My comment above about reusing Buf applies here and everywhere else.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/const.move.pass.cpp

1 ↗

(On Diff #557562)

Name of the file: cons.move.pass.cpp instead of const.move.pass.cpp?

33 ↗

(On Diff #557562)

Buf buf = std::move(b);

For implicit-ness?

44 ↗

(On Diff #557562)

Consider using b1 and b2 or something like that to make it clearer what is what. Just a suggestion.

135 ↗

(On Diff #557562)

Not attached to this file: can we add a dtor.pass.cpp test that ensures that we call emit()?

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/emit.pass.cpp

1 ↗

(On Diff #557562)

You swapped the filename with the one for set_emit_on_sync.pass.cpp.

27 ↗

(On Diff #557562)

I can't find a test for sync. There is a protected method sync() but I don't see a test for it either, I think.

29 ↗

(On Diff #557562)

We should at least run the code buff.set_emit_on_sync, right now we don't even codegen it.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/get_wrapped.pass.cpp

29–30 ↗

(On Diff #557562)

That way we test the return type properly.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/helpers.h

32–36 ↗

(On Diff #557562)

Can we replace this by the usual test_allocator?

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/set_emit_on_sync.pass.cpp

27 ↗

(On Diff #557562)

libcxx/test/std/input.output/syncstream/syncbuf/types.compile.pass.cpp

36–41 ↗

(On Diff #557562)

I think we should remove the third assertion here.

63–64 ↗

(On Diff #557562)

Same here, remove.

libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp

15–19

This synopsis is wrong. I think this is the sync test we were looking for earlier.

37

Should we comment that this calls buff.sync() under the hood?

[Mordante]

libcxx/include/syncstream

158

I prefer to do this in a followup commit. I feel the commit is already quite large and I prefer generic tools not to be hidden in these commits.

387

I prefer this too for a separate review. Especially since I already have something not generic in the implementation of format. That could benefit from a generic routine. The same for the places that use the now deprecated get_temporary_buffer. That would allow us to properly deprecate that function.

libcxx/test/std/input.output/syncstream/osyncstream/members/get_wrapped.pass.cpp

1 ↗

(On Diff #557562)

Indeed we are, added it.

libcxx/test/std/input.output/syncstream/osyncstream/syncstream.osyncstream.cons/cons.move.pass.cpp

54 ↗

(On Diff #557562)

I like the current way slightly better.

[Mordante]

Addresses review comments.

[ldionne]

libcxx/include/syncstream

158

Can we file a Github issue and add a TODO here to look into this? That way, we have something actionable to follow up on in a PR in the near future after shipping this patch.

387

This review is extremely relevant for any attempt to remove temporary_buffer again: https://reviews.llvm.org/D152208

FWIW I think we should 100% do it and we meant to pick this up again but it hasn't happened yet.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[Mordante]

Rebased and addresses review comments.

[Mordante]

Seems some of the comments I marked as done were not registered in Phab. Reviewed the entire patch again, all should be done now.

libcxx/include/map

1702–1703 ↗

(On Diff #557562)

https://github.com/llvm/llvm-project/issues/70696

libcxx/include/syncstream

158

https://github.com/llvm/llvm-project/issues/70697

442–445

Actually this header should provide them. When not doing that the std modules fail, so I reverted this part and the other using.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.assign/assign.pass.cpp

17 ↗

(On Diff #557562)

Actually it's not a noexcept function per https://cplusplus.github.io/LWG/issue3867. I had already updated the header but not the synopsis here. I added the other return type test.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.cons/const.move.pass.cpp

33 ↗

(On Diff #557562)

As mentioned I prefer this way.

135 ↗

(On Diff #557562)

I've added the test based on the emit test.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/emit.pass.cpp

27 ↗

(On Diff #557562)

Updated the comment, it was already tested.

libcxx/test/std/input.output/syncstream/syncbuf/syncstream.syncbuf.members/helpers.h

32–36 ↗

(On Diff #557562)

This is again a special allocator. As mentioned during a live review we should look at the number of "test allocators" we have and try to get a good set. I feel that's out of scope for this patch.

libcxx/test/std/input.output/syncstream/syncbuf/types.compile.pass.cpp

36–41 ↗

(On Diff #557562)

Odd I'm 100% certain I removed them before, seems I did make an error with the previous update.

[ldionne]

I suggest we ship this but guard it under -fexperimental-library since we know there are some things we want to improve. That way there's no risk of shipping it before we're confident about our implementation choices.

libcxx/include/syncstream

3

473

[ldionne]

libcxx/docs/FeatureTestMacroTable.rst

281 ↗

(On Diff #557940)

We should mention this in a release note (but mention it is experimental).

[Mordante]

Rebased and addresses are review comments.
Give it a CI run to test the change to the experimental library.

libcxx/include/iosfwd

 typedef basic_ostringstream<wchar_t> wostringstream;
 typedef basic_stringstream<wchar_t>  wstringstream;
 
 typedef basic_filebuf<wchar_t>       wfilebuf;
 typedef basic_ifstream<wchar_t>      wifstream;
 typedef basic_ofstream<wchar_t>      wofstream;
 typedef basic_fstream<wchar_t>       wfstream;
 
 template <class state> class fpos;
 typedef fpos<char_traits<char>::state_type>    streampos;
 typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
 
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_syncbuf;
+
+using syncbuf = basic_syncbuf<char>;
+using wsyncbuf = basic_syncbuf<wchar_t>;
+
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_osyncstream;
+
+using osyncstream = basic_osyncstream<char>;
+using wosyncstream = basic_osyncstream<wchar_t>;
+
 }  // std
 
 */
 
 #include <__config>
 #include <wchar.h>  // for mbstate_t
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

 #ifndef _LIBCPP_NO_HAS_CHAR8_T
 typedef fpos<mbstate_t>    u8streampos;
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
+#if _LIBCPP_STD_VER > 17
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_syncbuf;
+
+using syncbuf = basic_syncbuf<char>;
+using wsyncbuf = basic_syncbuf<wchar_t>;
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_osyncstream;
+
+using osyncstream = basic_osyncstream<char>;
+using wosyncstream = basic_osyncstream<wchar_t>;
+
+#endif // _LIBCPP_STD_VER > 17
+
 #if defined(_NEWLIB_VERSION)
 // On newlib, off_t is 'long int'
 typedef long int streamoff;         // for char_traits in <string>
 #else
 typedef long long streamoff;        // for char_traits in <string>
 #endif
 
 template <class _CharT,             // for <stdexcept>

libcxx/include/syncstream

+// -*- C++ -*-
+//===--------------------------- sstream ----------------------------------===//
+//
+// 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 _LIBCPP_SYNCSTREAM
+#define _LIBCPP_SYNCSTREAM
+
+/*
+    syncstream synopsis
+
+#include <ostream>  // see [ostream.syn]
+
+namespace std {
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf;
+
+    using syncbuf = basic_syncbuf<char>;
+    using wsyncbuf = basic_syncbuf<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream;
+
+    using osyncstream = basic_osyncstream<char>;
+    using wosyncstream = basic_osyncstream<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf : public basic_streambuf<charT, traits> {
+    public:
+        using char_type      = charT;
+        using int_type       = typename traits::int_type;
+        using pos_type       = typename traits::pos_type;
+        using off_type       = typename traits::off_type;
+        using traits_type    = traits;
+        using allocator_type = Allocator;
+
+        using streambuf_type = basic_streambuf<charT, traits>;
+
+        // [syncstream.syncbuf.cons], construction and destruction
+        explicit basic_syncbuf(streambuf_type* obuf = nullptr)
+          : basic_syncbuf(obuf, Allocator()) {}
+        basic_syncbuf(streambuf_type*, const Allocator&);
+        basic_syncbuf(basic_syncbuf&&);
+        ~basic_syncbuf();
+
+        // [syncstream.syncbuf.assign], assignment and swap
+        basic_syncbuf& operator=(basic_syncbuf&&);
+        void swap(basic_syncbuf&);
+
+        // [syncstream.syncbuf.members], member functions
+        bool emit();
+        streambuf_type* get_wrapped() const noexcept;
+        allocator_type get_allocator() const noexcept;
+        void set_emit_on_sync(bool) noexcept;
+
+    protected:
+        // [syncstream.syncbuf.virtuals], overridden virtual functions
+        int sync() override;
+
+    private:
+        streambuf_type* wrapped;    // exposition only
+        bool emit_on_sync{};        // exposition only
+    };
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              basic_syncbuf<charT, traits, Allocator>&);
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream : public basic_ostream<charT, traits> {
+    public:
+        using char_type   = charT;
+        using int_type    = typename traits::int_type;
+        using pos_type    = typename traits::pos_type;
+        using off_type    = typename traits::off_type;
+        using traits_type = traits;
+
+        using allocator_type = Allocator;
+        using streambuf_type = basic_streambuf<charT, traits>;
+        using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
+
+        // [syncstream.osyncstream.cons], construction and destruction
+        basic_osyncstream(streambuf_type*, const Allocator&);
+        explicit basic_osyncstream(streambuf_type* obuf)
+          : basic_osyncstream(obuf, Allocator()) {}
+        basic_osyncstream(basic_ostream<charT, traits>& os, const Allocator& allocator)
+          : basic_osyncstream(os.rdbuf(), allocator) {}
+        explicit basic_osyncstream(basic_ostream<charT, traits>& os)
+          : basic_osyncstream(os, Allocator()) {}
+        basic_osyncstream(basic_osyncstream&&) noexcept;
+        ~basic_osyncstream();
+
+        // [syncstream.osyncstream.assign], assignment
+        basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
+
+        // [syncstream.osyncstream.members], member functions
+        void emit();
+        streambuf_type* get_wrapped() const noexcept;
+        syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
+
+    private:
+        syncbuf_type sb;    // exposition only
+    };
+}
+
+*/
+
+#include <__config>
+#include <ostream>
+#include <iosfwd>
+#include <mutex>
+#include <map>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// basic_syncbuf
+
+
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_syncbuf
+    : public basic_streambuf<_CharT, _Traits>
+{
+public:
+    typedef _CharT                         char_type;
+    typedef _Traits                        traits_type;
+    typedef typename traits_type::int_type int_type;
+    typedef typename traits_type::pos_type pos_type;
+    typedef typename traits_type::off_type off_type;
+    typedef _Allocator                     allocator_type;
+
+    typedef basic_streambuf<_CharT, _Traits>                 streambuf_type;
+    typedef _VSTD::shared_ptr<_VSTD::mutex>                  mutex_ptr_type;
+    typedef _VSTD::basic_string<_CharT, _Traits, _Allocator> string_type;
+
+    // [syncstream.syncbuf.cons], construction and destruction
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    explicit basic_syncbuf(streambuf_type* __obuf = nullptr)
+        : basic_syncbuf(__obuf, _Allocator()) { }
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    basic_syncbuf(streambuf_type* __obuf, _Allocator const& __alloc);
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    basic_syncbuf(basic_syncbuf&& __other);
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    ~basic_syncbuf();
+
+    // [syncstream.syncbuf.assign], assignment and swap
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    basic_syncbuf& operator=(basic_syncbuf&& __other);
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    void swap(basic_syncbuf&& __other);
+
+    // [syncstream.syncbuf.members], member functions
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    bool emit();
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    streambuf_type* get_wrapped() const noexcept;
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    allocator_type  get_allocator() const noexcept;
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    void set_emit_on_sync(bool __b) noexcept;
+
+protected:
+
+    // [syncstream.syncbuf.virtuals], overridden virtual functions
+
+    int sync() override;
+
+    int_type overflow(int_type __c = traits_type::eof()) override;
+
+private:
+    streambuf_type* __wrapped;
+    allocator_type  __alloc;
+    string_type     __str;
+    bool __emit_on_sync;
+    bool __should_flush;
+};
+
+// Each basic_streambuf needs to have exactly one mutex that it corresponds to.
+// If there are 100 osyncstreams we still need each one to map to the correct mutex.
+// So, below is a global map that maps streambuf pointers to mutex. This is used in emit.
+// void* used as key so that only one instance of this function is created (no template).
+_VSTD::map<void*, _VSTD::shared_ptr<_VSTD::mutex>>&
+__get_mtx_ptr_map()
+{
+    static _VSTD::map<void*, _VSTD::shared_ptr<_VSTD::mutex>> __mtx_ptr_map;
+    return __mtx_ptr_map;
+}
+
+_VSTD::mutex&
+__get_map_mtx()
+{
+    static _VSTD::mutex __mtx;
+    return __mtx;
+}
+
+_VSTD::shared_ptr<_VSTD::mutex>&
+__get_mtx_for_ptr(void* __ptr)
+{
+    _VSTD::mutex& __mtx = __get_map_mtx();
+    _VSTD::lock_guard<_VSTD::mutex> __gaurd(__mtx);
+
+    auto& __mtx_ptr_map = __get_mtx_ptr_map();
+    auto __mtx_ptr = __mtx_ptr_map[__ptr];
+    assert(__mtx_ptr != nullptr && "This should never be nullptr");
+    return __mtx_ptr;
+}
+
+void
+__make_mtx_for_ptr(void* __ptr)
+{
+    _VSTD::mutex& __mtx = __get_map_mtx();
+    _VSTD::lock_guard<_VSTD::mutex> __gaurd(__mtx);
+
+    auto& __mtx_ptr_map = __get_mtx_ptr_map();
+    if (!__mtx_ptr_map.contains(__ptr))
+        __mtx_ptr_map[__ptr] = _VSTD::make_shared<_VSTD::mutex>();
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_syncbuf<_CharT, _Traits, _Allocator>::basic_syncbuf(streambuf_type* __obuf,
+                                                          _Allocator const& __alloc)
+    : __wrapped(__obuf),
+      __alloc(__alloc)
+{
+    __make_mtx_for_ptr(__obuf);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_syncbuf<_CharT, _Traits, _Allocator>::basic_syncbuf(basic_syncbuf&& __other)
+    : __wrapped(_VSTD::move(__other.get_wrapped())),
+      __alloc  (_VSTD::move(__other.get_allocator()))
+{
+    __other.__wrapped = nullptr;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_syncbuf<_CharT, _Traits, _Allocator>::~basic_syncbuf()
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+        emit();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch(...) { }
+#endif // _LIBCPP_NO_EXCEPTIONS
+}
+
+// [syncstream.syncbuf.assign], assignment and swap
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_syncbuf<_CharT, _Traits, _Allocator>&
+basic_syncbuf<_CharT, _Traits, _Allocator>::operator=(basic_syncbuf&& __other)
+{
+    __wrapped = _VSTD::move(__other.get_wrapped());
+    __alloc = _VSTD::move(__other.get_allocator());
+    __other.__wrapped = nullptr;
+    return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+basic_syncbuf<_CharT, _Traits, _Allocator>::swap(basic_syncbuf&& __other)
+{
+    basic_syncbuf __tmp(_VSTD::move(__other));
+    __other = _VSTD::move(*this);
+    *this = _VSTD::move(__tmp);
+}
+
+// [syncstream.syncbuf.members], member functions
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+basic_syncbuf<_CharT, _Traits, _Allocator>::emit()
+{
+    bool __result = true;
+    mutex_ptr_type __mtx = __get_mtx_for_ptr(__wrapped);
+
+    if (__wrapped == nullptr || __mtx == nullptr)
+        __result = false;
+
+    if (__result)
+    {
+        _VSTD::lock_guard<_VSTD::mutex> gaurd(*__mtx);
+
+        if (this->pptr())
+        {
+            __result &= (__wrapped->sputn(__str.data(), __str.size()) != -1);
+            this->setp(nullptr, nullptr);
+        }
+
+        if (__should_flush)
+            __result &= (__wrapped->pubsync() != -1);
+    }
+
+    __should_flush = false;
+    return __result;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+typename basic_syncbuf<_CharT, _Traits, _Allocator>::streambuf_type*
+basic_syncbuf<_CharT, _Traits, _Allocator>::get_wrapped() const noexcept
+{
+    return __wrapped;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+typename basic_syncbuf<_CharT, _Traits, _Allocator>::allocator_type
+basic_syncbuf<_CharT, _Traits, _Allocator>::get_allocator() const noexcept
+{
+    return __alloc;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+basic_syncbuf<_CharT, _Traits, _Allocator>::set_emit_on_sync(bool __b) noexcept
+{
+    __emit_on_sync = __b;
+}
+
+// [syncstream.syncbuf.virtuals], overridden virtual functions
+
+template <class _CharT, class _Traits, class _Allocator>
+int
+basic_syncbuf<_CharT, _Traits, _Allocator>::sync()
+{
+    __should_flush = true;
+
+    if (__emit_on_sync && !emit())
+        return -1;
+    return 0;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+typename basic_syncbuf<_CharT, _Traits, _Allocator>::int_type
+basic_syncbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
+{
+    if (traits_type::eq_int_type(__c, traits_type::eof()))
+        return traits_type::not_eof(__c);
+
+    if (this->pptr() == this->epptr())
+    {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif // _LIBCPP_NO_EXCEPTIONS
+            __str.resize(__str.capacity());
+
+            char_type *__p = static_cast<char_type*>(__str.data());
+            this->setp(__p, __p + __str.size());
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+            return traits_type::eof();
+        }
+#endif // _LIBCPP_NO_EXCEPTIONS
+    }
+
+    return this->sputc(traits_type::to_char_type(__c));
+}
+
+// basic_osyncstream
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_osyncstream
+    : public basic_ostream<_CharT, _Traits>
+{
+public:
+    typedef _CharT                         char_type;
+    typedef _Traits                        traits_type;
+    typedef typename traits_type::int_type int_type;
+    typedef typename traits_type::pos_type pos_type;
+    typedef typename traits_type::off_type off_type;
+    typedef _Allocator                     allocator_type;
+
+    typedef basic_streambuf<char_type, traits_type>               streambuf_type;
+    typedef basic_syncbuf<char_type, traits_type, allocator_type> syncbuf_type;
+
+    // [syncstream.osyncstream.cons], construction and destruction
+
+    basic_osyncstream(streambuf_type *__obuf, allocator_type const& __alloc)
+        : basic_ostream<_CharT, _Traits>(addressof(__sb)),
+          __sb(__obuf, __alloc) { }
+
+    explicit basic_osyncstream(streambuf_type *__obuf)
+      : basic_osyncstream(__obuf, allocator_type()) { }
+
+    basic_osyncstream(basic_ostream<char_type, traits_type>& __os, allocator_type const& __alloc)
+      : basic_osyncstream(__os.rdbuf(), __alloc) { }
+
+    explicit basic_osyncstream(basic_ostream<char_type, traits_type>& __os)
+      : basic_osyncstream(__os, allocator_type()) { }
+
+    basic_osyncstream(basic_osyncstream&& __other) noexcept;
+
+    ~basic_osyncstream();
+
+    // [syncstream.osyncstream.assign], assignment
+
+    basic_osyncstream& operator=(basic_osyncstream&& __other) noexcept;
+
+    // [syncstream.osyncstream.members], member functions
+
+    void emit();
+
+    streambuf_type* get_wrapped() const noexcept;
+
+    syncbuf_type* rdbuf() const noexcept;
+
+private:
+    syncbuf_type __sb;
+};
+
+// [syncstream.osyncstream.cons], construction and destruction
+
+template <class _CharT, class _Traits, class _Allocator>
+basic_osyncstream<_CharT, _Traits, _Allocator>::basic_osyncstream(basic_osyncstream&& __other)
+    noexcept
+    : basic_ostream<_CharT, _Traits>(addressof(__sb)),
+      __sb(_VSTD::move(__other.__sb))
+{
+    this->set_rdbuf(addressof(__sb));
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+basic_osyncstream<_CharT, _Traits, _Allocator>::~basic_osyncstream()
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+        emit();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch(...) { }
+#endif // _LIBCPP_NO_EXCEPTIONS
+}
+
+// [syncstream.osyncstream.assign], assignment
+
+template <class _CharT, class _Traits, class _Allocator>
+basic_osyncstream<_CharT, _Traits, _Allocator>&
+basic_osyncstream<_CharT, _Traits, _Allocator>::operator=(basic_osyncstream&& __other) noexcept
+{
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_NO_EXCEPTIONS
+        emit();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    } catch(...) { }
+#endif // _LIBCPP_NO_EXCEPTIONS
+
+    __sb = _VSTD::move(__other.__sb);
+    return *this;
+}
+
+// [syncstream.osyncstream.members], member functions
+
+template <class _CharT, class _Traits, class _Allocator>
+void
+basic_osyncstream<_CharT, _Traits, _Allocator>::emit()
+{
+    if (__sb.emit() == false)
+        this->setstate(ios::badbit);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+typename basic_osyncstream<_CharT, _Traits, _Allocator>::streambuf_type*
+basic_osyncstream<_CharT, _Traits, _Allocator>::get_wrapped() const noexcept
+{
+    return __sb.get_wrapped();
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+typename basic_osyncstream<_CharT, _Traits, _Allocator>::syncbuf_type*
+basic_osyncstream<_CharT, _Traits, _Allocator>::rdbuf() const noexcept
+{
+    return const_cast<syncbuf_type*>(addressof(__sb));
+}
+
+#endif  // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif  // _LIBCPP_SYNCSTREAM

libcxx/test/std/input.output/syncstream/osyncstream/assign.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream& operator=(basic_osyncstream&& rhs) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+struct test_allocator : std::allocator<T>
+{
+    int id;
+    int moves = 0;
+    int copies = 0;
+
+    test_allocator(int id = 0) : id(id) { }
+    test_allocator(test_allocator const& other)
+        : id(other.id), moves(other.moves), copies(other.copies) { }
+    test_allocator(test_allocator&& other)
+        : id(std::move(other.id)),
+          moves(std::move(other.moves)),
+          copies(std::move(other.copies)) { }
+};
+
+template<class T>
+class test_buf
+    : public std::basic_streambuf<T> {
+};
+
+template<class CharT>
+void test_assign()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+    test_buf<CharT> base;
+    test_allocator<CharT> alloc(42);
+    OS out1(&base, alloc);
+    typename OS::syncbuf_type *buff1 = out1.rdbuf();
+
+    assert(out1.get_wrapped() == &base);
+    assert(buff1->get_wrapped() == &base);
+
+    OS out2 = std::move(out1);
+    typename OS::syncbuf_type *buff2 = out2.rdbuf();
+
+    assert(out2.get_wrapped() == &base);
+    assert(buff2->get_wrapped() == &base);
+    assert(buff2->get_allocator().id == alloc.id);
+    assert(out1.get_wrapped() == nullptr);
+    assert(buff1->get_wrapped() == nullptr);
+}
+
+int main(int, char**)
+{
+    test_assign<char>();
+    test_assign<wchar_t>();
+    test_assign<uint8_t>();
+    test_assign<int>();
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/osyncstream/const.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// basic_osyncstream(streambuf_type* buf, const Allocator& allocator);
+// basic_osyncstream(basic_osyncstream&& other) noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+
+template<class T>
+struct test_allocator : std::allocator<T>
+{
+    int id;
+    int moves = 0;
+    int copies = 0;
+
+    test_allocator(int id = 0) : id(id) { }
+    test_allocator(test_allocator const& other)
+        : id(other.id), moves(other.moves), copies(other.copies) { }
+    test_allocator(test_allocator&& other)
+        : id(std::move(other.id)),
+          moves(std::move(other.moves)),
+          copies(std::move(other.copies)) { }
+};
+
+template<class T>
+class test_buf
+    : public std::basic_streambuf<T> {
+};
+
+template<class CharT>
+void test_const()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+    test_buf<CharT> base;
+    test_allocator<CharT> alloc(42);
+    OS out(&base, alloc);
+    typename OS::syncbuf_type *buff = out.rdbuf();
+
+    assert(out.get_wrapped() == &base);
+    assert(buff->get_wrapped() == &base);
+    assert(buff->get_allocator().id == alloc.id);
+};
+
+template<class CharT>
+void test_rvalue()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+    test_buf<CharT> base;
+    test_allocator<CharT> alloc(42);
+    OS out1(&base, alloc);
+    typename OS::syncbuf_type *buff1 = out1.rdbuf();
+
+    assert(out1.get_wrapped() == &base);
+    assert(buff1->get_wrapped() == &base);
+
+    OS out2(std::move(out1));
+    typename OS::syncbuf_type *buff2 = out2.rdbuf();
+
+    assert(out2.get_wrapped() == &base);
+    assert(buff2->get_wrapped() == &base);
+    assert(buff2->get_allocator().id == alloc.id);
+    assert(out1.get_wrapped() == nullptr);
+    assert(buff1->get_wrapped() == nullptr);
+}
+
+template<class CharT>
+void test_dest()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+    using SS = std::basic_ostringstream<CharT>;
+    CharT c = 'f';
+
+    SS ss;
+    {
+        OS out(ss);
+        out << c;
+        assert(ss.str().empty());
+    }
+    std::cout << ss.str() << std::endl;
+    assert(ss.str()[0] == c);
+}
+
+int main(int, char**)
+{
+    test_const<char>();
+    test_const<wchar_t>();
+    test_const<uint8_t>();
+    test_const<int>();
+
+    test_rvalue<char>();
+    test_rvalue<wchar_t>();
+    test_rvalue<uint8_t>();
+    test_rvalue<int>();
+
+    test_dest<char>();
+//     test_dest<wchar_t>();
+    // other overloads aren't tested because of bast_ostringstream
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/osyncstream/members.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// void emit();
+// streambuf_type* get_wrapped() const noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+class test_buf
+    : public std::basic_streambuf<T> {
+};
+
+template<class CharT>
+void test_emit()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+    using SS = std::basic_ostringstream<CharT>;
+    CharT c = 'f';
+
+    SS ss;
+    OS out(ss);
+    out << c;
+    assert(ss.str().empty());
+    out.emit();
+    assert(ss.str()[0] == c);
+}
+
+template<class CharT>
+void test_get_wrapped()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+    test_buf<CharT> base;
+    std::allocator<CharT> alloc;
+    OS out(&base, alloc);
+    assert(out.get_wrapped() == &base);
+    ASSERT_NOEXCEPT(out.get_wrapped());
+}
+
+template<class CharT>
+void test_rdbuf()
+{
+    using OS = std::basic_osyncstream<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+    test_buf<CharT> base;
+    std::allocator<CharT> alloc;
+    OS out(&base, alloc);
+    assert(out.rdbuf() != nullptr);
+    ASSERT_SAME_TYPE(decltype(out.rdbuf()),
+                     std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>*);
+    ASSERT_NOEXCEPT(out.rdbuf());
+}
+
+int main(int, char**)
+{
+    test_emit<char>();
+    test_emit<wchar_t>();
+    // other overloads aren't tested because of bast_ostringstream
+
+    test_get_wrapped<char>();
+    test_get_wrapped<wchar_t>();
+    test_get_wrapped<int>();
+
+    test_rdbuf<char>();
+    test_rdbuf<wchar_t>();
+    test_rdbuf<int>();
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/osyncstream/thread/basic.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+// void emit();
+// streambuf_type* get_wrapped() const noexcept;
+
+#include <syncstream>
+#include <sstream>
+#include <mutex>
+#include <thread>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+
+using ms = std::chrono::milliseconds;
+using OS = std::basic_osyncstream<char, std::char_traits<char>, std::allocator<char>>;
+
+
+static std::basic_ostringstream<char> ss;
+static const char a = 'a';
+static const char b = 'b';
+static const char c = 'c';
+static const char d = 'd';
+
+void f1() {
+    OS out(ss);
+    out << a;
+    std::this_thread::sleep_for(ms(250));
+    out << b;
+}
+
+void f2() {
+    OS out(ss);
+    out << c;
+    out << d;
+}
+
+void test_mutlithread()
+{
+    std::thread t1(f1);
+    std::thread t2(f2);
+    t1.join();
+    t2.join();
+
+    assert(strcmp(ss.str().data(), "cdab"));
+}
+
+int main(int, char**)
+{
+    // tested with char only for now
+    test_mutlithread();
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/osyncstream/thread/several_threads.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_osyncstream;
+
+#include <syncstream>
+#include <sstream>
+#include <mutex>
+#include <thread>
+#include <cassert>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "test_macros.h"
+
+using OS = std::basic_osyncstream<char, std::char_traits<char>, std::allocator<char>>;
+
+static std::basic_ostringstream<char> ss;
+static std::unordered_multiset<std::string> test_strings =
+{
+"C++", "is", "a", "general-purpose", "programming", "language", "created", "by", "Bjarne", "Stroustrup", "as", "an", "extension", "of", "the", "C", "programming", "language,", "or", "C", "with", "Classes", "The", "language", "has", "expanded", "significantly", "over", "time,", "and", "modern", "C++", "has", "object-oriented,", "generic,", "and", "functional", "features", "in", "addition", "to", "facilities", "for", "low-level", "memory", "manipulation.", "It", "is", "almost", "always", "implemented", "as", "a", "compiled", "language,", "and", "many", "vendors", "provide", "C++", "compilers,", "including", "the", "Free", "Software", "Foundation,", "LLVM,", "Microsoft,", "Intel,", "and", "IBM,", "so", "it", "is", "available", "on", "many", "platforms."
+};
+
+void f(std::string text) {
+    OS out(ss);
+    out << text;
+}
+
+void test()
+{
+    ss = std::basic_ostringstream<char>();
+    std::vector<std::thread> threads;
+    for (std::string const& word : test_strings)
+        threads.push_back(std::thread(f, word));
+    for (size_t i = 0; i < test_strings.size(); (void)++i)
+        threads[i].join();
+
+    std::string output = ss.str();
+    for (std::string const& word : test_strings)
+        assert(output.find(word) != std::string::npos);
+}
+
+int main(int, char**)
+{
+    // The more we test, the more likely we catch an error
+    for (size_t i = 0; i < 10000; ++i)
+      test();
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/osyncstream/types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <iosfwd>
+// <syncstream>
+
+#include <iosfwd>
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class CharT>
+void test_member_types()
+{
+    using Buf = std::basic_syncbuf<CharT>;
+    using OSS = std::basic_osyncstream<CharT>;
+
+    ASSERT_SAME_TYPE(typename Buf::char_type, CharT);
+    ASSERT_SAME_TYPE(typename Buf::traits_type, std::char_traits<CharT>);
+    ASSERT_SAME_TYPE(typename Buf::allocator_type, std::allocator<CharT>);
+
+    ASSERT_SAME_TYPE(typename OSS::char_type, CharT);
+    ASSERT_SAME_TYPE(typename OSS::traits_type, std::char_traits<CharT>);
+    ASSERT_SAME_TYPE(typename OSS::allocator_type, std::allocator<CharT>);
+}
+
+int main(int, char**)
+{
+    ASSERT_SAME_TYPE(std::syncbuf, std::basic_syncbuf<char>);
+    ASSERT_SAME_TYPE(std::wsyncbuf, std::basic_syncbuf<wchar_t>);
+    ASSERT_SAME_TYPE(std::osyncstream, std::basic_osyncstream<char>);
+    ASSERT_SAME_TYPE(std::wosyncstream, std::basic_osyncstream<wchar_t>);
+
+    test_member_types<char>();
+    test_member_types<wchar_t>();
+
+    return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/syncbuf/assign.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
+// void swap(basic_syncbuf& other) noexcept;
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+class test_syncbuf
+    : public std::basic_syncbuf<T, std::char_traits<T>, std::allocator<T>> {
+};
+
+template<class CharT>
+void test_assign()
+{
+    using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+    test_syncbuf<CharT> base;
+    std::allocator<CharT> alloc;
+    BuffT buff1(&base, alloc);
+    BuffT buff2 = std::move(buff1);
+
+    assert(buff1.get_wrapped() == nullptr);
+    assert(buff2.get_wrapped() == &base);
+
+    // Also LWG issue?
+    // assert(buff1.rdbuf()->pbase() == buff1.rdbuf()->pptr());
+}
+
+template<class CharT>
+void test_swap()
+{
+    using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+    test_syncbuf<CharT> base1;
+    test_syncbuf<CharT> base2;
+    std::allocator<CharT> alloc;
+    BuffT buff1(&base1, alloc);
+    BuffT buff2(&base2, alloc);
+    buff1.swap(std::move(buff2));
+
+    assert(buff1.get_wrapped() == &base2);
+    assert(buff2.get_wrapped() == &base1);
+}
+
+int main(int, char**)
+{
+    test_assign<char>();
+    test_assign<wchar_t>();
+    test_assign<uint8_t>();
+    test_assign<int>();
+
+    test_swap<char>();
+    test_swap<wchar_t>();
+    test_swap<uint8_t>();
+    test_swap<int>();
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/syncbuf/cons.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+struct test_allocator : std::allocator<T>
+{
+    int id;
+    int moves = 0;
+    int copies = 0;
+
+    test_allocator(int id = 0) : id(id) { }
+    test_allocator(test_allocator const& other)
+        : id(other.id), moves(other.moves), copies(other.copies) { }
+    test_allocator(test_allocator&& other)
+        : id(std::move(other.id)),
+          moves(std::move(other.moves)),
+          copies(std::move(other.copies)) { }
+};
+
+template<class T>
+class test_buf
+    : public std::basic_streambuf<T> {
+};
+
+template<class CharT>
+void test_streambuf_const()
+{
+    using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+    test_buf<CharT> base;
+    test_allocator<CharT> alloc(42);
+    BuffT buff(&base, alloc);
+
+    assert(buff.get_wrapped() == &base);
+    assert(buff.get_allocator().id == alloc.id);
+}
+
+template<class CharT>
+void test_move_const()
+{
+    using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, test_allocator<CharT>>;
+
+    test_buf<CharT> base;
+    test_allocator<CharT> alloc(42);
+    BuffT buff1(&base, alloc);
+    BuffT buff2(std::move(buff1));
+
+    assert(buff1.get_wrapped() == nullptr);
+    assert(buff2.get_wrapped() == &base);
+
+    // LWG issue?
+    // assert(buff1.rdbuf()->pbase() == buff1.rdbuf()->pptr());
+}
+
+int main(int, char**)
+{
+    test_streambuf_const<char>();
+    test_streambuf_const<wchar_t>();
+    test_streambuf_const<uint8_t>();
+    test_streambuf_const<int>();
+
+    test_move_const<char>();
+    test_move_const<wchar_t>();
+    test_move_const<uint8_t>();
+    test_move_const<int>();
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/syncbuf/members.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+class test_buf : public std::basic_streambuf<T> {
+public:
+    int id;
+
+    test_buf(int id = 0) : id(id) { }
+
+    T *_pptr() { return this->pptr(); }
+};
+
+template<class T, class Alloc = std::allocator<T>>
+class test_syncbuf
+    : public std::basic_syncbuf<T, std::char_traits<T>, Alloc> {
+public:
+    test_syncbuf(test_buf<T>* buf, Alloc alloc)
+        : std::basic_syncbuf<T, std::char_traits<T>, Alloc>(buf, alloc) { }
+
+    void _setp(T *begin, T *end) {
+        return this->setp(begin, end);
+    }
+};
+
+template<class T>
+struct test_allocator : std::allocator<T>
+{
+    int id;
+    test_allocator(int id = 0) : id(id) { }
+};
+
+template<class CharT>
+void test_emit()
+{
+    // We do this because we want to be able to any CharT
+    CharT arr[3] = { 'a', 'b', 'c' };
+    CharT *ptr = arr;
+
+    test_buf<CharT> base;
+    std::allocator<CharT> alloc;
+    test_syncbuf<CharT> buff(&base, alloc);
+
+    buff._setp(ptr, ptr + 3);
+    assert(base._pptr() == nullptr);
+    buff.emit();
+    CharT *pptr = base._pptr();
+    while(pptr) { assert(*pptr++ == *ptr++); }
+}
+
+template<class T>
+void test_get_wrapped()
+{
+    test_buf<T> base(42);
+    std::allocator<T> alloc;
+    test_syncbuf<T> buff(&base, alloc);
+    assert(static_cast<test_buf<T>*>(buff.get_wrapped())->id == 42);
+    ASSERT_NOEXCEPT(buff.get_wrapped());
+}
+
+template<class T>
+void test_get_allocator()
+{
+    test_buf<T> base;
+    test_allocator<T> alloc(42);
+    test_syncbuf<T, test_allocator<T>> buff(&base, alloc);
+    assert(buff.get_allocator().id == 42);
+    ASSERT_NOEXCEPT(buff.get_allocator());
+}
+
+template<class T>
+void test_set_emit_on_sync()
+{
+    // set_emit_on_sync tested in sync
+    test_syncbuf<T, std::allocator<T>> buff(nullptr, std::allocator<T>());
+    ASSERT_NOEXCEPT(buff.set_emit_on_sync(false));
+}
+
+int main(int, char**)
+{
+    test_emit<char>();
+    test_emit<wchar_t>();
+    test_emit<uint8_t>();
+    test_emit<int>();
+
+    test_get_wrapped<char>();
+    test_get_wrapped<wchar_t>();
+    test_get_wrapped<uint8_t>();
+    test_get_wrapped<int>();
+
+    test_get_allocator<char>();
+    test_get_allocator<wchar_t>();
+    test_get_allocator<uint8_t>();
+    test_get_allocator<int>();
+
+    test_set_emit_on_sync<char>();
+    test_set_emit_on_sync<wchar_t>();
+    test_set_emit_on_sync<uint8_t>();
+    test_set_emit_on_sync<int>();
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/syncbuf/special.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+class test_streambuf
+    : public std::basic_streambuf<T> {
+};
+
+template<class CharT>
+void test_swap()
+{
+    using BuffT = std::basic_syncbuf<CharT, std::char_traits<CharT>, std::allocator<CharT>>;
+
+    test_streambuf<CharT> base1;
+    test_streambuf<CharT> base2;
+    std::allocator<CharT> alloc;
+    BuffT buff1(&base1, alloc);
+    BuffT buff2(&base2, alloc);
+    std::swap(buff1, buff2);
+
+    assert(buff1.get_wrapped() == &base2);
+    assert(buff2.get_wrapped() == &base1);
+}
+
+int main(int, char**)
+{
+    test_swap<char>();
+    test_swap<wchar_t>();
+    test_swap<uint8_t>();
+    test_swap<int>();
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/input.output/syncstream/syncbuf/virtuals.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <syncstream>
+
+// template <class charT, class traits, class Allocator>
+// class basic_syncbuf;
+
+// basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
+// basic_syncbuf(basic_syncbuf&& other);
+
+#include <syncstream>
+#include <sstream>
+#include <iostream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+class test_buf : public std::basic_streambuf<T> {
+public:
+    T *_pbase() { return this->pbase(); }
+};
+
+template<class T>
+class test_syncbuf
+    : public std::basic_syncbuf<T, std::char_traits<T>, std::allocator<T>> {
+public:
+    test_syncbuf(test_buf<T>* buf, std::allocator<T> alloc)
+        : std::basic_syncbuf<T, std::char_traits<T>, std::allocator<T>>(buf, alloc) { }
+
+    int _sync() {
+        return this->sync();
+    }
+};
+
+template<class CharT>
+void test_sync(bool emit_on_sync)
+{
+    std::basic_ostringstream<CharT> ss;
+    test_buf<CharT> *base = reinterpret_cast<test_buf<CharT>*>(ss.rdbuf());
+    std::allocator<CharT> alloc;
+    test_syncbuf<CharT> buff(base, alloc);
+    std::basic_ostream<CharT> out(&buff);
+
+    buff.set_emit_on_sync(emit_on_sync);
+    out << 'a';
+    assert(base->_pbase() == nullptr);
+    assert(buff._sync() == 0);
+
+    if (emit_on_sync)
+        assert(*base->_pbase() == 'a');
+    else
+        assert(base->_pbase() == nullptr);
+}
+
+int main(int, char**)
+{
+    test_sync<char>(true);
+    test_sync<wchar_t>(false);
+    test_sync<char>(true);
+    test_sync<wchar_t>(false);
+
+  return 0;
+}
 No newline at end of file

libcxx/www/cxx2a_status.html

 <!--
   <tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
   <tr><td><a href="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td>Complete</td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0674R1">P0674R1</a></td><td>LWG</td><td>Extending make_shared to Support Arrays</td><td>Toronto</td><td></td><td></td></tr>
 
     <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0020R6">P0020R6</a></td><td>LWG</td><td>Floating Point Atomic</td><td>Albuquerque</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0053R7">P0053R7</a></td><td>LWG</td><td>C++ Synchronized Buffered Ostream</td><td>Albuquerque</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0053R7">P0053R7</a></td><td>LWG</td><td>C++ Synchronized Buffered Ostream</td><td>Albuquerque</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0202R3">P0202R3</a></td><td>LWG</td><td>Add constexpr modifiers to functions in &lt;algorithm&gt; and &lt;utility&gt; Headers</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0415R1">P0415R1</a></td><td>LWG</td><td>Constexpr for <tt>std::complex</tt></td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0439R0">P0439R0</a></td><td>LWG</td><td>Make <tt>std::memory_order</tt> a scoped enumeration</td><td>Albuquerque</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0457R2">P0457R2</a></td><td>LWG</td><td>String Prefix and Suffix Checking</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
   <tr><td><a href="https://wg21.link/P0550R2">P0550R2</a></td><td>LWG</td><td>Transformation Trait <tt>remove_cvref</tt></td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
   <tr><td><a href="https://wg21.link/P0600R1">P0600R1</a></td><td>LWG</td><td>nodiscard in the Library</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
   <tr><td><a href="https://wg21.link/P0616R0">P0616R0</a></td><td>LWG</td><td>de-pessimize legacy <numeric> algorithms with std::move</td><td>Albuquerque</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0653R2">P0653R2</a></td><td>LWG</td><td>Utility to convert a pointer to a raw pointer</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>