[libc++][format][2/6] Adds a __output_iterator.

[Mordante]

Summary

Instead of using a temporary string in __vformat_to_wrapped use a new
generic iterator. This aids to reduce the number of template instantions
and avoids using a string to buffer the entire formatted output.

This changes the type of format_context and wformat_context, this can
still be done since the code isn't ABI stable yet.

Several approaches have been evaluated:

• Using a __output_buffer base class with:
  • a put function to store the buffer in its internal buffer
  • a virtual flush function to copy the internal buffer to the output
• Using a function to forward the output operation to the output buffer, much like the next method.
• Using a type erased function point to store the data in the buffer.

The last version resulted in the best performance. For some cases there's
still a loss of speed over the original method. This loss many becomes
apparent when large strings are copied to a pointer like iterator, before
the compiler optimized this using memcpy.

[• Quuxplusone]

libcxx/include/__format/buffer.h

30

/that too/it is too/?

39

Nit: type-erased hyphenated.

46–47

Generally I find the javadoc-style comments unhelpful; but also in this case it's a bit misleading, since of course __obj can't be any old class object containing a put; it must be the specific object, of the specific type, that you instantiated __put with (or that you instantiated __output_iterator's ctor with, if you take my refactor below). Fortunately, if you take my refactor below, then you won't need _Fun in multiple places and so you won't need a distinct name for it and so you won't need a comment about what the name means. :)

73–77

The comment is ungrammatical and unhelpful, and T needs uglification; but why just not make this a private detail of __output_iterator? Instead of

_LIBCPP_HIDE_FROM_ABI explicit __output_iterator(_Fun __fun, void* __obj)
    : __fun_(__fun), __obj_(__obj) {}

do

_LIBCPP_HIDE_FROM_ABI explicit __output_iterator(_Tp *__t)
    : __fun_([](_CharT __c, void *__o){ static_cast<_Tp*>(__o)->put(__c); }), __obj_(__t) {}

and construct it on line 504 as

_VSTD::__format::__output_iterator<_CharT>(_VSTD::addressof(__buffer))

(notice addressof, not operator&, for ADL-proofing and hijacking-avoidance)

85–86

Btw, I see some inconsistency throughout on whether we're doing 2-space tabs in this file or 4-space (lines 57, 88). Doesn't matter, though.

libcxx/test/libcxx/utilities/format/format.formatter/format.context/types.compile.pass.cpp

133

Your commit message implies that you did some performance testing benchmarks between this implementation and some other implementation. What were those benchmarks, and can you check them into libcxx/benchmarks/?

[Mordante]

libcxx/include/__format/buffer.h

30

I'll leave this as is since the same block is copied several times. Still hope we soon only need to support compilers with proper concepts support.

85–86

This is what clang-format makes of it. I noticed clang-format-13 seems to have some support for concepts and I still want to reformat all format related headers once we switch to clang-format-13 and the number of active format patches is reduced.

libcxx/test/libcxx/utilities/format/format.formatter/format.context/types.compile.pass.cpp

133

See D110501.

[Mordante]

libcxx/include/__format/buffer.h

73–77

Your suggestion indeed looks better than the current code. Thanks!

[Mordante]

Addresses review comments.
@Quuxplusone's suggestion to use a lambda instead of a helper function means the other patches in this series need to be adjusted in a similar fashion.

[Mordante]

Rebased; changes the generated files.

[Mordante]

Rebased to test with wchar_t changes.

[vitaut]

I'm very surprised that this is the solution you went with. Indirect function call to write each character individually will likely be slow in practice compared to a contiguous buffer and a bulk copy. Please post benchmark results.

[Mordante]

Thanks for the review. I'll try your suggestion and benchmark both versions.

[Mordante]

I've created a proof-of-concept here with benchmark results D112361.
That revision is just to show what I did. It's intended to be a basis for the changes, it *is not* to be used as-is.

[vitaut]

In D110495#3082114, @Mordante wrote:

I've created a proof-of-concept here with benchmark results D112361.
That revision is just to show what I did. It's intended to be a basis for the changes, it *is not* to be used as-is.

I think D112361 is a step in the right direction. You can do even better and make it represent a contiguous (not necessarily fixed-size) buffer with a single type-erased reallocation/flush function. Then it can be used to write to contiguous containers like vector and string which is a common case directly avoiding copies. This is basically what {fmt} does.

[Mordante]

Rebased and make changes based on D112361.

[vitaut]

libcxx/include/__format/buffer.h

58–60

As discussed in D112361, it would be good to avoid extra buffering for the common case of appending to a contiguous container such as string or vector.

[Mordante]

libcxx/include/__format/buffer.h

58–60

What do you mean with "appending"?
std::back_inserter(std::string) or std::string::begin()

I think it makes sense to buffer the back_inserter. For example every push_back in a std::string NUL-terminates the string. The insert operation does one NUL-termination.

D110497 changes the behaviour for these containers to buffer in this object and then use insert in these containers.

But I can test with the benchmarks whether the extra buffering has a positive or negative effect.

[vitaut]

libcxx/include/__format/buffer.h

58–60

What do you mean with "appending"?

std::back_inserter(std::string)

For example every push_back in a std::string NUL-terminates the string.

You should avoid character-by-character insertion in the first place. Also adding buffering for std::string is easy but you cannot remove it so the current approach is inherently less efficient than needed.

[Mordante]

libcxx/include/__format/buffer.h

58–60

I agree and I should improve this inefficiency. I added a todo on line 71 to that effect and have more todos for this in my personal notes.
For now my main focus is feature completeness, so I prefer to postpone these changes to a later time.
D110497 already has some improvements for containers, but for string and vector we can do better.

[Mordante]

Rebased and some minor improvements.

[Mordante]

Rebased to trigger CI.

[Mordante]

Removed related commits to fix CI patch application.

[vitaut]

As commented, I'm very skeptical about this approach because it has extra buffering for common cases but I defer to libc++ maintainers the decision whether they want to land this as is or optimize buffering now.

[ldionne]

Sorry, I hadn't seen this was waiting for some sort of resolution.

@Mordante do you have an already planned way of addressing the inefficiencies raised by @vitaut? If not, I'd like to have a solution for those before shipping this. Otherwise, there's a risk that we'll forget about it and eventually ship the library without these optimizations (which IIUC are not merely nice-to-haves, but really important basic guarantees). I especially want to avoid us being painted into a corner where these optimizations are difficult to achieve in the current design.

[Mordante]

In D110495#3306205, @ldionne wrote:

Sorry, I hadn't seen this was waiting for some sort of resolution.

No problem I was busy with other format parts which I wanted in LLVM 14. Otherwise I would have pinged you on Discord.

@Mordante do you have an already planned way of addressing the inefficiencies raised by @vitaut? If not, I'd like to have a solution for those before shipping this. Otherwise, there's a risk that we'll forget about it and eventually ship the library without these optimizations (which IIUC are not merely nice-to-haves, but really important basic guarantees). I especially want to avoid us being painted into a corner where these optimizations are difficult to achieve in the current design.

I've ideas how I want to address these inefficiencies and added TODOs in the code. Before we mark format as complete I will review those TODOs and see whether they are blocking for marking the implementation complete. For example after moving the floating-point formatter to the dylib the proper long double implementation won't be an ABI break. (This requires long double support in to_chars. I want to tackle that, but it isn't trivial.)

The current changes in this series are an improvement. Especially for formatted_size and format_to_n that now use a string as temporary buffer.

I prefer to land the current improvement and look at further optimizations later.

[ldionne]

Looking at patches 4 and 5 in the series, I think this seems reasonable since the buffering issue is being addressed AFAIU.

[Mordante]

Rebased to test CI and require compilers with concepts.

[Mordante]

Fix CI.

[Mordante]

As discussed on Discord more buffer optimization can be achieved, but that will be done in separate patches.

[Mordante]

Fix CI.

[Mordante]

Fix Windows CI.

libcxx/include/CMakeLists.txt

set(files
   __filesystem/operations.h
   __filesystem/path.h
   __filesystem/path_iterator.h
   __filesystem/perm_options.h
   __filesystem/perms.h
   __filesystem/recursive_directory_iterator.h
   __filesystem/space_info.h
   __filesystem/u8path.h
+  __format/buffer.h
   __format/format_arg.h
   __format/format_args.h
   __format/format_context.h
   __format/format_error.h
   __format/format_fwd.h
   __format/format_parse_context.h
   __format/format_string.h
   __format/format_to_n_result.h

libcxx/include/__format/buffer.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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___FORMAT_BUFFER_H
+#define _LIBCPP___FORMAT_BUFFER_H
+
+#include <__algorithm/copy_n.h>
+#include <__algorithm/unwrap_iter.h>
+#include <__config>
+#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
+#include <__iterator/back_insert_iterator.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/wrap_iter.h>
+#include <__utility/move.h>
+#include <concepts>
+#include <cstddef>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+namespace __format {
+
+/// A "buffer" that handles writing to the proper iterator.
+///
+/// This helper is used together with the @ref back_insert_iterator to offer
+/// type-erasure for the formatting functions. This reduces the number to
+/// template instantiations.
+template <__formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __output_buffer {
+public:
+  using value_type = _CharT;
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr,
+                                                 size_t __capacity, _Tp* __obj)
+      : __ptr_(__ptr), __capacity_(__capacity),
+        __flush_([](_CharT* __p, size_t __size, void* __o) {
+          static_cast<_Tp*>(__o)->flush(__p, __size);
+        }),
+        __obj_(__obj) {}
+
+  _LIBCPP_HIDE_FROM_ABI void reset(_CharT* __ptr, size_t __capacity) {
+    __ptr_ = __ptr;
+    __capacity_ = __capacity;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
+    return back_insert_iterator{*this};
+  }
+
+  // TODO FMT It would be nice to have an overload taking a
+  // basic_string_view<_CharT> and append it directly.
+  _LIBCPP_HIDE_FROM_ABI void push_back(_CharT __c) {
+    __ptr_[__size_++] = __c;
+
+    // Profiling showed flushing after adding is more efficient than flushing
+    // when entering the function.
+    if (__size_ == __capacity_)
+      flush();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void flush() {
+    __flush_(__ptr_, __size_, __obj_);
+    __size_ = 0;
+  }
+
+private:
+  _CharT* __ptr_;
+  size_t __capacity_;
+  size_t __size_{0};
+  void (*__flush_)(_CharT*, size_t, void*);
+  void* __obj_;
+};
+
+/// A storage using an internal buffer.
+///
+/// This storage is used when writing a single element to the output iterator
+/// is expensive.
+template <__formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __internal_storage {
+public:
+  _LIBCPP_HIDE_FROM_ABI _CharT* begin() { return __buffer_; }
+  _LIBCPP_HIDE_FROM_ABI size_t capacity() { return __buffer_size_; }
+
+private:
+  static constexpr size_t __buffer_size_ = 256 / sizeof(_CharT);
+  _CharT __buffer_[__buffer_size_];
+};
+
+/// A storage writing directly to the storage.
+///
+/// This requires the storage to be a contiguous buffer of \a _CharT.
+/// Since the output is directly written to the underlying storage this class
+/// is just an empty class.
+template <__formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __direct_storage {};
+
+template <class _OutIt, class _CharT>
+concept __enable_direct_output = __formatter::__char_type<_CharT> &&
+    (same_as<_OutIt, _CharT*>
+#if _LIBCPP_DEBUG_LEVEL < 2
+     || same_as<_OutIt, __wrap_iter<_CharT*>>
+#endif
+    );
+
+/// Write policy for directly writing to the underlying output.
+template <class _OutIt, __formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __writer_direct {
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
+      : __out_it_(__out_it) {}
+
+  _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }
+
+  _LIBCPP_HIDE_FROM_ABI void flush(_CharT*, size_t __size) {
+    // _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
+    // is adjusted.
+    __out_it_ += __size;
+  }
+
+private:
+  _OutIt __out_it_;
+};
+
+/// Write policy for copying the buffer to the output.
+template <class _OutIt, __formatter::__char_type _CharT>
+class _LIBCPP_TEMPLATE_VIS __writer_iterator {
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
+      : __out_it_{_VSTD::move(__out_it)} {}
+
+  _LIBCPP_HIDE_FROM_ABI auto out() { return __out_it_; }
+
+  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
+    __out_it_ = _VSTD::copy_n(__ptr, __size, _VSTD::move(__out_it_));
+  }
+
+private:
+  _OutIt __out_it_;
+};
+
+/// Selects the type of the writer used for the output iterator.
+template <class _OutIt, class _CharT>
+class _LIBCPP_TEMPLATE_VIS __writer_selector {
+public:
+  using type = conditional_t<__enable_direct_output<_OutIt, _CharT>,
+                             __writer_direct<_OutIt, _CharT>,
+                             __writer_iterator<_OutIt, _CharT>>;
+};
+
+/// The generic formatting buffer.
+template <class _OutIt, __formatter::__char_type _CharT>
+requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
+    __format_buffer {
+  using _Storage =
+      conditional_t<__enable_direct_output<_OutIt, _CharT>,
+                    __direct_storage<_CharT>, __internal_storage<_CharT>>;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
+      same_as<_Storage, __internal_storage<_CharT>>)
+      : __output_(__storage_.begin(), __storage_.capacity(), this),
+        __writer_(_VSTD::move(__out_it)) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
+      same_as<_Storage, __direct_storage<_CharT>>)
+      : __output_(_VSTD::__unwrap_iter(__out_it), size_t(-1), this),
+        __writer_(_VSTD::move(__out_it)) {}
+
+  _LIBCPP_HIDE_FROM_ABI auto make_output_iterator() {
+    return __output_.make_output_iterator();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void flush(_CharT* __ptr, size_t __size) {
+    __writer_.flush(__ptr, __size);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _OutIt out() && {
+    __output_.flush();
+    return _VSTD::move(__writer_).out();
+  }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _Storage __storage_;
+  __output_buffer<_CharT> __output_;
+  typename __writer_selector<_OutIt, _CharT>::type __writer_;
+};
+} // namespace __format
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_BUFFER_H

libcxx/include/__format/format_context.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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___FORMAT_FORMAT_CONTEXT_H
 #define _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 
 #include <__availability>
 #include <__config>
+#include <__format/buffer.h>
 #include <__format/format_args.h>
 #include <__format/format_fwd.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <concepts>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <locale>

 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
 __format_context_create(
     _OutIt __out_it,
     basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
   return _VSTD::basic_format_context(_VSTD::move(__out_it), __args);
 }
 #endif
 
-// TODO FMT Implement [format.context]/4
-// [Note 1: For a given type charT, implementations are encouraged to provide a
-// single instantiation of basic_format_context for appending to
-// basic_string<charT>, vector<charT>, or any other container with contiguous
-// storage by wrapping those in temporary objects with a uniform interface
-// (such as a span<charT>) and polymorphic reallocation. - end note]
-
-using format_context = basic_format_context<back_insert_iterator<string>, char>;
+using format_context =
+    basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
+                         char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wformat_context = basic_format_context<back_insert_iterator<wstring>, wchar_t>;
+using wformat_context = basic_format_context<
+    back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>;
 #endif
 
 template <class _OutIt, class _CharT>
 requires output_iterator<_OutIt, const _CharT&>
 class
     // clang-format off
     _LIBCPP_TEMPLATE_VIS
     _LIBCPP_AVAILABILITY_FORMAT

libcxx/include/format

 // Make sure all feature-test macros are available.
 #include <version>
 // Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES.
 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
 
 #include <__algorithm/clamp.h>
 #include <__config>
 #include <__debug>
+#include <__format/buffer.h>
 #include <__format/format_arg.h>
 #include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
 #include <__format/format_to_n_result.h>
requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
   else {
-    basic_string<_CharT> __str;
+    __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args));
-    return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it));
+        _VSTD::__format_context_create(__buffer.make_output_iterator(),
+                                       __args));
+    return _VSTD::move(__buffer).out();
   }
 }
 
 template <output_iterator<const char&> _OutIt>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt
 vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
 }
__vformat_to(
         _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
         _VSTD::__format_context_create(_VSTD::move(__out_it), __args,
                                        _VSTD::move(__loc)));
   else {
-    basic_string<_CharT> __str;
+    __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
     _VSTD::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args,
-                                       _VSTD::move(__loc)));
-    return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it));
+        _VSTD::__format_context_create(__buffer.make_output_iterator(),
+                                       __args, _VSTD::move(__loc)));
+    return _VSTD::move(__buffer).out();
   }
 }
 
 template <output_iterator<const char&> _OutIt>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to(
     _OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
   return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
                              __args);

libcxx/include/module.modulemap

module __filesystem {
       module u8path                       { private header "__filesystem/u8path.h" }
     }
   }
   module format {
     header "format"
     export *
 
     module __format {
+      module buffer                   { private header "__format/buffer.h" }
       module format_arg               { private header "__format/format_arg.h" }
       module format_args              { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
       }
       module format_error             { private header "__format/format_error.h" }

libcxx/test/libcxx/diagnostics/detail.headers/format/buffer.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/buffer.h'}}
+#include <__format/buffer.h>

libcxx/test/libcxx/utilities/format/format.formatter/format.context/types.compile.pass.cpp

 //   template<class T> using formatter_type = formatter<T, charT>;
 // }
 //
 // Namespace std typedefs:
 // using format_context = basic_format_context<unspecified, char>;
 // using wformat_context = basic_format_context<unspecified, wchar_t>;
 
 #include <format>
-#include <string>
 #include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class OutIt, class CharT>
 constexpr void test() {
   static_assert(
static_assert(
                      std::formatter<std::basic_string_view<CharT>, CharT>>);
   static_assert(
       std::is_same_v<typename std::basic_format_context<
                          OutIt, CharT>::template formatter_type<const void*>,
                      std::formatter<const void*, CharT>>);
 }
 
 constexpr void test() {
-  test<std::back_insert_iterator<std::basic_string<char>>, char>();
+  test<std::back_insert_iterator<std::__format::__output_buffer<char>>, char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>();
+  test<std::back_insert_iterator<std::__format::__output_buffer<wchar_t>>,
+       wchar_t>();
 #endif
-  test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>();
-  test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>();
-  test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>();
 }
 
 template <class, class>
 constexpr bool is_basic_format_context_specialization = false;
 template <class It, class CharT>
 constexpr bool is_basic_format_context_specialization<std::basic_format_context<It, CharT>, CharT> = true;
 
 static_assert(is_basic_format_context_specialization<std::format_context, char>);
-LIBCPP_STATIC_ASSERT(
+static_assert(
     std::is_same_v<
         std::format_context,
         std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<char>>, char>>);
+            std::back_insert_iterator<std::__format::__output_buffer<char>>,
+            char>>);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(is_basic_format_context_specialization<std::wformat_context, wchar_t>);
 LIBCPP_STATIC_ASSERT(
     std::is_same_v<
         std::wformat_context,
         std::basic_format_context<
-            std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>);
+            std::back_insert_iterator< std::__format::__output_buffer<wchar_t>>,
+            wchar_t>>);
 #endif
-
-// Required for MSVC internal test runner compatibility.
-int main(int, char**) { return 0; }