libstdc++: Implement P3107R5 optimizations for std::print [PR121790]

The names of the vprint functions follow the convention from P3235R3.

This takes advantage of the additional permission proposed by P3107R5 so
that std::print can write directly to a FILE stream, rather than
formatting to an intermediate std::string temporary and then writing
that to the stream. The change is to write to a new _File_sink type
instead of a _Str_sink that populates a std::string. There are three
implementations of _File_sink.

For non-Glibc targets that support POSIX flockfile and putc_unlocked,
the stream will be locked and then formatted characters will be buffered
on the stack (instead of allocating a std::string) and copied to the
stream when the buffer fills up.

For Glibc, _File_sink will lock the stream but then if the file is
line-buffered or fully buffered, characters will be written directly
into the file's output buffer. This avoids two levels of buffering and
copying the characters from one to the other. For an unbuffered stream
(like stderr) the _File_sink buffer will still be used, to avoid the
overhead of lots of small writes to the stream.  Because this version of
_File_sink accesses the stream's buffer directly it relies on
glibc-specific implementation details that are exposed in public
headers.

A fallback definition of _File_sink just wraps a _Str_sink so is
equivalent to the original code, and is used when flockfile isn't
available.

Both forms of std::println (taking a FILE* and a std::ostream) can be
implemented more efficiently by appending a newline to the format
string, to avoid formatting twice.

	PR libstdc++/121790

libstdc++-v3/ChangeLog:

	* acinclude.m4 (GLIBCXX_CHECK_STDIO_LOCKING): New macro to check
	for std::print dependencies.
	* config.h.in: Regenerate.
	* configure: Regenerate.
	* configure.ac: Use GLIBCXX_CHECK_STDIO_LOCKING.
	* include/bits/formatfwd.h (enable_nonlocking_formatter_optimization):
	Define new variable template.
	* include/bits/version.def (print): Bump value.
	* include/bits/version.h: Regenerate.
	* include/std/format (enable_nonlocking_formatter_optimization):
	Define specializations for variable template.
	* include/std/ostream (print) [!_WIN32]: Do not use
	vprint_unicode at all.
	(println): Append newline to format string instead of formatting
	twice.
	* include/std/print (_File_sink): New class.
	(vprint_nonunicode_locking): New function.
	(vprint_unicode_locking): New function reusing previous code
	from vprint_unicode.
	(vprintf_unicode): Defer to vprint_nonunicode for Windows or to
	vprint_unicode_locking otherwise.
	(print): [!_WIN32]: Do no use vprint_unicode at all.
	Check enable_nonlocking_formatter_optimization and defer to
	either vprint_nonunicode_locking or vprint_nonunicode.
	(println): Use vprint_unicode or format directly to a _File_sink
	instead of formatting twice.
	* testsuite/27_io/print/1.cc: Updated and added new tests.
	* testsuite/std/format/formatter/nonlocking.cc: New tests.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Co-authored-by: Tomasz Kamiński <tkaminsk@redhat.com>

Author: jwakely

libstdc++-v3/acinclude.m4

@@ -5804,6 +5804,89 @@ AC_DEFUN([GLIBCXX_CHECK_DEBUGGING], [
   AC_LANG_RESTORE
 ])
 
+dnl
+dnl Check whether the dependencies for optimized std::print are available.
+dnl
+dnl Defines:
+dnl   _GLIBCXX_USE_STDIO_LOCKING if flockfile, putc_unlocked etc. are present.
+dnl   _GLIBCXX_USE_GLIBC_STDIO_EXT if FILE::_IO_write_ptr etc. are also present.
+dnl
+AC_DEFUN([GLIBCXX_CHECK_STDIO_LOCKING], [
+AC_LANG_SAVE
+  AC_LANG_CPLUSPLUS
+
+  AC_MSG_CHECKING([whether flockfile and putc_unlocked are defined in <stdio.h>])
+  AC_TRY_COMPILE([
+  #include <stdio.h>
+  ],[
+    FILE* f = ::fopen("", "");
+    ::flockfile(f);
+    ::putc_unlocked(' ', f);
+    ::funlockfile(f);
+    ::fclose(f);
+  ], [ac_stdio_locking=yes], [ac_stdio_locking=no])
+  AC_MSG_RESULT($ac_stdio_locking)
+
+  if test "$ac_stdio_locking" = yes; then
+    AC_DEFINE_UNQUOTED(_GLIBCXX_USE_STDIO_LOCKING, 1,
+      [Define if flockfile and putc_unlocked should be used for std::print.])
+
+    # This is not defined in POSIX, but is present in glibc, musl, and Solaris.
+    AC_MSG_CHECKING([whether fwrite_unlocked is defined in <stdio.h>])
+    AC_TRY_COMPILE([
+    #include <stdio.h>
+    ],[
+      FILE* f = ::fopen("", "");
+      ::flockfile(f);
+      ::fwrite_unlocked("", 1, 1, f);
+      ::funlockfile(f);
+      ::fclose(f);
+    ], [ac_fwrite_unlocked=yes], [ac_fwrite_unlocked=no])
+    AC_MSG_RESULT($ac_fwrite_unlocked)
+    if test "$ac_fwrite_unlocked" = yes; then
+      AC_DEFINE(HAVE_FWRITE_UNLOCKED, 1,
+	[Define if fwrite_unlocked can be used for std::print.])
+
+      # Check for Glibc-specific FILE members and <stdio_ext.h> extensions.
+      case "${target_os}" in
+	gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
+	  AC_MSG_CHECKING([for FILE::_IO_write_ptr and <stdio_ext.h>])
+	  AC_TRY_COMPILE([
+	  #include <stdio.h>
+	  #include <stdio_ext.h>
+	  extern "C" {
+	   using f1_type = int (*)(FILE*) noexcept;
+	   using f2_type = size_t (*)(FILE*) noexcept;
+	  }
+	  ],[
+	  f1_type twritable = &::__fwritable;
+	  f1_type tblk = &::__flbf; 
+	  f2_type pbufsize = &::__fbufsize;
+	  FILE* f = ::fopen("", "");
+	  int i = ::__overflow(f, EOF);
+	  bool writeable = ::__fwritable(f);
+	  bool line_buffered = ::__flbf(f);
+	  size_t bufsz = ::__fbufsize(f);
+	  char*& pptr = f->_IO_write_ptr;
+	  char*& epptr = f->_IO_buf_end;
+	  ::fflush_unlocked(f);
+	  ::fclose(f);
+	  ], [ac_glibc_stdio=yes], [ac_glibc_stdio=no])
+	  AC_MSG_RESULT($ac_glibc_stdio)
+	  if test "$ac_glibc_stdio" = yes; then
+	    AC_DEFINE_UNQUOTED(_GLIBCXX_USE_GLIBC_STDIO_EXT, 1,
+	      [Define if Glibc FILE internals should be used for std::print.])
+	  fi
+	  ;;
+	*)
+	  ;;
+      esac
+    fi
+  fi
+
+  AC_LANG_RESTORE
+])
+
 
 # Macros from the top-level gcc directory.
 m4_include([../config/gc++filt.m4])

libstdc++-v3/config.h.in

@@ -152,6 +152,9 @@
 /* Define to 1 if you have the `frexpl' function. */
 #undef HAVE_FREXPL
 
+/* Define if fwrite_unlocked can be used for std::print. */
+#undef HAVE_FWRITE_UNLOCKED
+
 /* Define if getentropy is available in <unistd.h>. */
 #undef HAVE_GETENTROPY
 
@@ -828,6 +831,9 @@
 /* Define if get_nprocs is available in <sys/sysinfo.h>. */
 #undef _GLIBCXX_USE_GET_NPROCS
 
+/* Define if Glibc FILE internals should be used for std::print. */
+#undef _GLIBCXX_USE_GLIBC_STDIO_EXT
+
 /* Define if init_priority should be used for iostream initialization. */
 #undef _GLIBCXX_USE_INIT_PRIORITY_ATTRIBUTE
 
@@ -893,6 +899,9 @@
 /* Define if sendfile is available in <sys/sendfile.h>. */
 #undef _GLIBCXX_USE_SENDFILE
 
+/* Define if flockfile and putc_unlocked should be used for std::print. */
+#undef _GLIBCXX_USE_STDIO_LOCKING
+
 /* Define to restrict std::__basic_file<> to stdio APIs. */
 #undef _GLIBCXX_USE_STDIO_PURE
 

libstdc++-v3/configure

@@ -54949,6 +54949,154 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
 
+# For std::print
+
+
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether flockfile and putc_unlocked are defined in <stdio.h>" >&5
+$as_echo_n "checking whether flockfile and putc_unlocked are defined in <stdio.h>... " >&6; }
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+  #include <stdio.h>
+
+int
+main ()
+{
+
+    FILE* f = ::fopen("", "");
+    ::flockfile(f);
+    ::putc_unlocked(' ', f);
+    ::funlockfile(f);
+    ::fclose(f);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_stdio_locking=yes
+else
+  ac_stdio_locking=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_stdio_locking" >&5
+$as_echo "$ac_stdio_locking" >&6; }
+
+  if test "$ac_stdio_locking" = yes; then
+
+cat >>confdefs.h <<_ACEOF
+#define _GLIBCXX_USE_STDIO_LOCKING 1
+_ACEOF
+
+
+    # This is not defined in POSIX, but is present in glibc, musl, and Solaris.
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether fwrite_unlocked is defined in <stdio.h>" >&5
+$as_echo_n "checking whether fwrite_unlocked is defined in <stdio.h>... " >&6; }
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+    #include <stdio.h>
+
+int
+main ()
+{
+
+      FILE* f = ::fopen("", "");
+      ::flockfile(f);
+      ::fwrite_unlocked("", 1, 1, f);
+      ::funlockfile(f);
+      ::fclose(f);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_fwrite_unlocked=yes
+else
+  ac_fwrite_unlocked=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fwrite_unlocked" >&5
+$as_echo "$ac_fwrite_unlocked" >&6; }
+    if test "$ac_fwrite_unlocked" = yes; then
+
+$as_echo "#define HAVE_FWRITE_UNLOCKED 1" >>confdefs.h
+
+
+      # Check for Glibc-specific FILE members and <stdio_ext.h> extensions.
+      case "${target_os}" in
+	gnu* | linux* | kfreebsd*-gnu | knetbsd*-gnu)
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE::_IO_write_ptr and <stdio_ext.h>" >&5
+$as_echo_n "checking for FILE::_IO_write_ptr and <stdio_ext.h>... " >&6; }
+	  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	  #include <stdio.h>
+	  #include <stdio_ext.h>
+	  extern "C" {
+	   using f1_type = int (*)(FILE*) noexcept;
+	   using f2_type = size_t (*)(FILE*) noexcept;
+	  }
+
+int
+main ()
+{
+
+	  f1_type twritable = &::__fwritable;
+	  f1_type tblk = &::__flbf;
+	  f2_type pbufsize = &::__fbufsize;
+	  FILE* f = ::fopen("", "");
+	  int i = ::__overflow(f, EOF);
+	  bool writeable = ::__fwritable(f);
+	  bool line_buffered = ::__flbf(f);
+	  size_t bufsz = ::__fbufsize(f);
+	  char*& pptr = f->_IO_write_ptr;
+	  char*& epptr = f->_IO_buf_end;
+	  ::fflush_unlocked(f);
+	  ::fclose(f);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_glibc_stdio=yes
+else
+  ac_glibc_stdio=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_glibc_stdio" >&5
+$as_echo "$ac_glibc_stdio" >&6; }
+	  if test "$ac_glibc_stdio" = yes; then
+
+cat >>confdefs.h <<_ACEOF
+#define _GLIBCXX_USE_GLIBC_STDIO_EXT 1
+_ACEOF
+
+	  fi
+	  ;;
+	*)
+	  ;;
+      esac
+    fi
+  fi
+
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
 # Define documentation rules conditionally.
 
 # See if makeinfo has been installed and is modern enough

libstdc++-v3/configure.ac

@@ -590,6 +590,9 @@ GLIBCXX_CHECK_TEXT_ENCODING
 # For std::is_debugger_present
 GLIBCXX_CHECK_DEBUGGING
 
+# For std::print
+GLIBCXX_CHECK_STDIO_LOCKING
+
 # Define documentation rules conditionally.
 
 # See if makeinfo has been installed and is modern enough

libstdc++-v3/include/bits/formatfwd.h

@@ -190,6 +190,11 @@ namespace __format
     }();
 #endif // format_ranges
 
+#if __glibcxx_print >= 202403L
+  template<typename>
+    constexpr bool enable_nonlocking_formatter_optimization = false;
+#endif
+
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // __glibcxx_format

libstdc++-v3/include/bits/version.def

@@ -1865,7 +1865,7 @@ ftms = {
 ftms = {
   name = print;
   values = {
-    v = 202211;
+    v = 202403;
     cxxmin = 23;
     hosted = yes;
   };

libstdc++-v3/include/bits/version.h

@@ -2083,9 +2083,9 @@
 
 #if !defined(__cpp_lib_print)
 # if (__cplusplus >= 202100L) && _GLIBCXX_HOSTED
-#  define __glibcxx_print 202211L
+#  define __glibcxx_print 202403L
 #  if defined(__glibcxx_want_all) || defined(__glibcxx_want_print)
-#   define __cpp_lib_print 202211L
+#   define __cpp_lib_print 202403L
 #  endif
 # endif
 #endif /* !defined(__cpp_lib_print) */