RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-11 21:57:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Drop an unnecessary use of writev.

Browse Source 
It looks like the code this patch deletes is based on a misunderstanding of
what guarantees writev provides. In particular, writev with 1 iovec is
not "more atomic" than a write.

Testing on OS X shows that both write and writev from multiple processes
can be intermixed.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255837 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2015-12-16 22:59:06 +00:00
parent 7a36028a83
commit bb7c983c5a
2 changed files with 2 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/llvm/Support/raw_ostream.h
View File

@ -349,10 +349,6 @@ class raw_fd_ostream : public raw_pwrite_stream {
///
bool Error;
/// Controls whether the stream should attempt to use atomic writes, when
/// possible.
bool UseAtomicWrites;
uint64_t pos;
bool SupportsSeeking;
@ -402,16 +398,6 @@ public:
/// to the offset specified from the beginning of the file.
uint64_t seek(uint64_t off);
/// Set the stream to attempt to use atomic writes for individual output
/// routines where possible.
///
/// Note that because raw_ostream's are typically buffered, this flag is only
/// sensible when used on unbuffered streams which will flush their output
/// immediately.
void SetUseAtomicWrites(bool Value) {
UseAtomicWrites = Value;
}
raw_ostream &changeColor(enum Colors colors, bool bold=false,
bool bg=false) override;
raw_ostream &resetColor() override;

18
lib/Support/raw_ostream.cpp
View File

@ -517,7 +517,7 @@ raw_fd_ostream::raw_fd_ostream(StringRef Filename, std::error_code &EC,
/// closes the file when the stream is destroyed.
raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
: raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose),
Error(false), UseAtomicWrites(false) {
Error(false) {
if (FD < 0 ) {
ShouldClose = false;
return;
@ -568,21 +568,7 @@ void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
pos += Size;
do {
ssize_t ret;
// Check whether we should attempt to use atomic writes.
if (LLVM_LIKELY(!UseAtomicWrites)) {
ret = ::write(FD, Ptr, Size);
} else {
// Use ::writev() where available.
#if defined(HAVE_WRITEV)
const void *Addr = static_cast<const void *>(Ptr);
struct iovec IOV = {const_cast<void *>(Addr), Size };
ret = ::writev(FD, &IOV, 1);
#else
ret = ::write(FD, Ptr, Size);
#endif
}
ssize_t ret = ::write(FD, Ptr, Size);
if (ret < 0) {
// If it's a recoverable error, swallow it and retry the write.