raw_ostream: while it is generally desirable to do larger writes, it can lead to

inefficient file system buffering if the writes are not a multiple of the desired
buffer size. Avoid this by limiting the large write to a multiple of the buffer
size and copying the remainder into the buffer.

Thanks to Dan for pointing this out.

llvm-svn: 127026

1 files changed, 7 insertions, 3 deletions

diff --git a/llvm/lib/Support/raw_ostream.cpp b/llvm/lib/Support/raw_ostream.cpp
index b8839e2943b..b175d203a18 100644
--- a/llvm/lib/Support/raw_ostream.cpp
+++ b/llvm/lib/Support/raw_ostream.cpp
@@ -265,16 +265,20 @@ raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
       return write(Ptr, Size);
     }
 
+    size_t NumBytes = OutBufEnd - OutBufCur;
+
     // If the buffer is empty at this point we have a string that is larger
-    // than the buffer. It's better to write it unbuffered in this case.
+    // than the buffer. Directly write the chunk that is a multiple of the
+    // preferred buffer size and put the remainder in the buffer.
     if (BUILTIN_EXPECT(OutBufCur == OutBufStart, false)) {
-      write_impl(Ptr, Size);
+      size_t BytesToWrite = Size - (Size % NumBytes);
+      write_impl(Ptr, BytesToWrite);
+      copy_to_buffer(Ptr + BytesToWrite, Size - BytesToWrite);
       return *this;
     }
 
     // We don't have enough space in the buffer to fit the string in. Insert as
     // much as possible, flush and start over with the remainder.
-    size_t NumBytes = OutBufEnd - OutBufCur;
     copy_to_buffer(Ptr, NumBytes);
     flush_nonempty();
     return write(Ptr + NumBytes, Size - NumBytes);