[llvm-branch-commits] [libcxx] [libc++] Implements filebuf unbuffered. (PR #76629)
Mark de Wever via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Dec 30 11:39:29 PST 2023
https://github.com/mordante created https://github.com/llvm/llvm-project/pull/76629
When calling setbuf(nullptr, 0) before performing file operations it should set the file to unbuffered mode. Currently the code avoids buffering internally, but the underlying stream still can buffer.
This is addressed by disabling the buffering of the underlying stream.
Fixes: https://github.com/llvm/llvm-project/issues/60509
>From a68f28e4b5e2ef7c2df9ce286a747931bbf0dfe7 Mon Sep 17 00:00:00 2001
From: Mark de Wever <koraq at xs4all.nl>
Date: Sat, 30 Dec 2023 20:33:25 +0100
Subject: [PATCH] [libc++] Implements filebuf unbuffered.
When calling setbuf(nullptr, 0) before performing file operations it
should set the file to unbuffered mode. Currently the code avoids
buffering internally, but the underlying stream still can buffer.
This is addressed by disabling the buffering of the underlying stream.
Fixes: https://github.com/llvm/llvm-project/issues/60509
---
libcxx/include/fstream | 47 ++++++-
.../fstreams/filebuf.virtuals/setbuf.pass.cpp | 118 ++++++++++++++++++
2 files changed, 164 insertions(+), 1 deletion(-)
create mode 100644 libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/setbuf.pass.cpp
diff --git a/libcxx/include/fstream b/libcxx/include/fstream
index 21fee202873e76..8a2df123486556 100644
--- a/libcxx/include/fstream
+++ b/libcxx/include/fstream
@@ -276,6 +276,30 @@ private:
state_type __st_;
state_type __st_last_;
ios_base::openmode __om_;
+ // Used to track the currently used mode and track whether the output should
+ // be unbuffered.
+ // [filebuf.virtuals]/12
+ // If setbuf(0, 0) is called on a stream before any I/O has occurred on
+ // that stream, the stream becomes unbuffered. Otherwise the results are
+ // implementation-defined.
+ // This allows calling setbuf(0, 0)
+ // - before opening a file,
+ // - after opening a file, before
+ // - a read
+ // - a write
+ // - a seek.
+ // Note that opening a file with ios_base::ate does a seek operation.
+ // Normally underflow, overflow, and sync change this flag to
+ // ios_base::in, ios_base_out, or 0.
+ //
+ // The ios_base::trunc and ios_base::ate flags are used in the following way:
+ // - ios_base::trunc is set upon construction to indicate the unbuffered
+ // state can be set. When requesting unbuffered output and the file is open
+ // sets the mode. Else places a request by adding the ios_base::ate flag.
+ // - When a file is opened it checks whether both ios_base::trunc and
+ // ios_base::ate are set. If so switches to unbuffered mode.
+ // - Using ase::ate in the open mode sets the flag to 0 so future calls to
+ // setbuf no longer try to set the unbuffered mode.
ios_base::openmode __cm_;
bool __owns_eb_;
bool __owns_ib_;
@@ -294,7 +318,10 @@ private:
return nullptr;
__om_ = __mode;
+ __try_set_unbuffered_mode();
+
if (__mode & ios_base::ate) {
+ __cm_ = 0;
if (fseek(__file_, 0, SEEK_END)) {
fclose(__file_);
__file_ = nullptr;
@@ -304,6 +331,23 @@ private:
return this;
}
+
+ _LIBCPP_HIDE_FROM_ABI void __try_set_unbuffered_mode() {
+ if (__cm_ == (ios_base::trunc | ios_base::ate)) {
+ std::setbuf(__file_, nullptr);
+ __cm_ = 0;
+ }
+ }
+ _LIBCPP_HIDE_FROM_ABI void __try_set_unbuffered_mode(char_type* __s, streamsize __n) {
+ if (__cm_ == ios_base::trunc && __s == nullptr && __n == 0) {
+ if (__file_) {
+ std::setbuf(__file_, nullptr);
+ __cm_ = 0;
+ } else {
+ __cm_ = ios_base::trunc | ios_base::ate;
+ }
+ }
+ }
};
template <class _CharT, class _Traits>
@@ -319,7 +363,7 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf()
__st_(),
__st_last_(),
__om_(0),
- __cm_(0),
+ __cm_(ios_base::trunc),
__owns_eb_(false),
__owns_ib_(false),
__always_noconv_(false) {
@@ -780,6 +824,7 @@ template <class _CharT, class _Traits>
basic_streambuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) {
this->setg(nullptr, nullptr, nullptr);
this->setp(nullptr, nullptr);
+ __try_set_unbuffered_mode(__s, __n);
if (__owns_eb_)
delete[] __extbuf_;
if (__owns_ib_)
diff --git a/libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/setbuf.pass.cpp b/libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/setbuf.pass.cpp
new file mode 100644
index 00000000000000..3f561170f5fb24
--- /dev/null
+++ b/libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/setbuf.pass.cpp
@@ -0,0 +1,118 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <fstream>
+
+// basic_streambuf<charT, traits>* setbuf(char_type* s, streamsize n) override;
+
+#include <fstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+static std::size_t file_size(const char* filename) {
+ FILE* f = std::fopen(filename, "rb");
+ fseek(f, 0, SEEK_END);
+ long result = ftell(f);
+ fclose(f);
+ return result;
+}
+
+template <class CharT>
+struct filebuf : public std::basic_filebuf<CharT> {
+ CharT* base() { return this->pbase(); }
+ CharT* ptr() { return this->pptr(); }
+};
+
+template <class CharT>
+static void buffered_request() {
+ filebuf<CharT> buffer;
+
+ CharT b[10] = {0};
+ assert(buffer.pubsetbuf(b, 10) == &buffer);
+
+ buffer.open("test.dat", std::ios_base::out);
+ buffer.sputc(CharT('a'));
+ assert(b[0] == 'a');
+
+ buffer.close();
+ assert(file_size<CharT>("test.dat") == 1);
+}
+
+template <class CharT>
+static void unbuffered_request_before_open() {
+ filebuf<CharT> buffer;
+
+ assert(buffer.pubsetbuf(nullptr, 0) == &buffer);
+ assert(buffer.base() == nullptr);
+ assert(buffer.ptr() == nullptr);
+
+ buffer.open("test.dat", std::ios_base::out);
+ assert(buffer.base() == nullptr);
+ assert(buffer.ptr() == nullptr);
+
+ buffer.sputc(CharT('a'));
+ assert(buffer.base() == nullptr);
+ assert(buffer.ptr() == nullptr);
+
+ assert(file_size<CharT>("test.dat") == 1);
+}
+
+template <class CharT>
+static void unbuffered_request_after_open() {
+ filebuf<CharT> buffer;
+
+ buffer.open("test.dat", std::ios_base::out);
+
+ assert(buffer.pubsetbuf(nullptr, 0) == &buffer);
+ assert(buffer.base() == nullptr);
+ assert(buffer.ptr() == nullptr);
+
+ buffer.sputc(CharT('a'));
+ assert(buffer.base() == nullptr);
+ assert(buffer.ptr() == nullptr);
+
+ assert(file_size<CharT>("test.dat") == 1);
+}
+
+template <class CharT>
+static void unbuffered_request_after_open_ate() {
+ filebuf<CharT> buffer;
+
+ buffer.open("test.dat", std::ios_base::out | std::ios_base::ate);
+
+ assert(buffer.pubsetbuf(nullptr, 0) == &buffer);
+
+ buffer.sputc(CharT('a'));
+ assert(file_size<CharT>("test.dat") <= 1);
+ // on libc++ buffering is used by default.
+ LIBCPP_ASSERT(file_size<CharT>("test.dat") == 0);
+
+ buffer.close();
+ assert(file_size<CharT>("test.dat") == 1);
+}
+
+template <class CharT>
+static void test() {
+ buffered_request<CharT>();
+
+ unbuffered_request_before_open<CharT>();
+ unbuffered_request_after_open<CharT>();
+ unbuffered_request_after_open_ate<CharT>();
+}
+
+int main(int, char**) {
+ test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+ test<wchar_t>();
+#endif
+
+ return 0;
+}
More information about the llvm-branch-commits
mailing list