From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id 0611338582AD; Tue, 8 Nov 2022 17:44:23 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0611338582AD DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1667929463; bh=XbHeYrLEve++8/GgjRs43Vk305V+g3PD3iFr/7detzU=; h=From:To:Subject:Date:From; b=kGN5lsVemFCKgEB1wlWG1FWIx0oudgUDufeHsKXSKkIZxkvezctWtp1RHXKwxI0Lh rnrybPSINvXr+MV2b7xE+Z5BE66O+H2Z90SxA5MmeToLxoFzACFYmhlqlrGVsUzJXn cWAMVIWHBK2Vt1Jp56n2U3cGhB6V0NY5s2DGnH4o= MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="utf-8" From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r13-3815] libstdc++: basic_filebuf: don't flush more often than necessary [PR63746] X-Act-Checkin: gcc X-Git-Author: =?utf-8?q?Charles-Fran=C3=A7ois_Natali?= X-Git-Refname: refs/heads/master X-Git-Oldrev: c93baa93df2d454f329a38686affcfe1a1339766 X-Git-Newrev: 3f1519eef5cbdcea2f18445852f5482798e3936a Message-Id: <20221108174423.0611338582AD@sourceware.org> Date: Tue, 8 Nov 2022 17:44:23 +0000 (GMT) List-Id: https://gcc.gnu.org/g:3f1519eef5cbdcea2f18445852f5482798e3936a commit r13-3815-g3f1519eef5cbdcea2f18445852f5482798e3936a Author: Charles-François Natali Date: Thu Oct 6 20:02:56 2022 +0100 libstdc++: basic_filebuf: don't flush more often than necessary [PR63746] `basic_filebuf::xsputn` would bypass the buffer when passed a chunk of size 1024 and above, seemingly as an optimisation. This can have a significant performance impact if the overhead of a `write` syscall is non-negligible, e.g. on a slow disk, on network filesystems, or simply during IO contention because instead of flushing every `BUFSIZ` (by default), we can flush every 1024 char. The impact is even greater with custom larger buffers, e.g. for network filesystems, because the code could issue `write` for example 1000X more often than necessary with respect to the buffer size. It also introduces a significant discontinuity in performance when writing chunks of size 1024 and above. Instead, it makes sense to only bypass the buffer if the amount of data to be written is larger than the buffer capacity. Signed-off-by: Charles-Francois Natali libstdc++-v3/ChangeLog: PR libstdc++/63746 * include/bits/fstream.tcc (basic_filbuf::xsputn): Remove 1024-byte chunking that bypasses the buffer for large writes. * testsuite/27_io/basic_filebuf/sputn/char/63746.cc: New test. Diff: --- libstdc++-v3/include/bits/fstream.tcc | 9 ++--- .../27_io/basic_filebuf/sputn/char/63746.cc | 38 ++++++++++++++++++++++ 2 files changed, 41 insertions(+), 6 deletions(-) diff --git a/libstdc++-v3/include/bits/fstream.tcc b/libstdc++-v3/include/bits/fstream.tcc index 7ccc887b882..2e936962837 100644 --- a/libstdc++-v3/include/bits/fstream.tcc +++ b/libstdc++-v3/include/bits/fstream.tcc @@ -757,23 +757,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { streamsize __ret = 0; // Optimization in the always_noconv() case, to be generalized in the - // future: when __n is sufficiently large we write directly instead of - // using the buffer. + // future: when __n is larger than the available capacity we write + // directly instead of using the buffer. const bool __testout = (_M_mode & ios_base::out || _M_mode & ios_base::app); if (__check_facet(_M_codecvt).always_noconv() && __testout && !_M_reading) { - // Measurement would reveal the best choice. - const streamsize __chunk = 1ul << 10; streamsize __bufavail = this->epptr() - this->pptr(); // Don't mistake 'uncommitted' mode buffered with unbuffered. if (!_M_writing && _M_buf_size > 1) __bufavail = _M_buf_size - 1; - const streamsize __limit = std::min(__chunk, __bufavail); - if (__n >= __limit) + if (__n >= __bufavail) { const streamsize __buffill = this->pptr() - this->pbase(); const char* __buf = reinterpret_cast(this->pbase()); diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/sputn/char/63746.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/sputn/char/63746.cc new file mode 100644 index 00000000000..baab9340734 --- /dev/null +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/sputn/char/63746.cc @@ -0,0 +1,38 @@ +// { dg-require-fileio "" } + +#include +#include + +class testbuf : public std::filebuf { +public: + char_type* pub_pprt() const + { + return this->pptr(); + } + + char_type* pub_pbase() const + { + return this->pbase(); + } +}; + +void test01() +{ + using namespace std; + + // Leave capacity to avoid flush. + const streamsize chunk_size = BUFSIZ - 1 - 1; + const char data[chunk_size] = {}; + + testbuf a_f; + VERIFY( a_f.open("tmp_63746_sputn", ios_base::out) ); + VERIFY( chunk_size == a_f.sputn(data, chunk_size) ); + VERIFY( (a_f.pub_pprt() - a_f.pub_pbase()) == chunk_size ); + VERIFY( a_f.close() ); +} + +int main() +{ + test01(); + return 0; +}