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.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@127026 91177308-0d34-0410-b5e6-96231b3b80d8

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);