[Support] Don't initialize compressed buffer allocated by zlib::compress

[MaskRay]

Summary

Initialization (zeroing) makes makes every allocated page resident. The actual size of the compressed buffer is usually much smaller. Making every page resident is wasteful.

When linking a test binary with ~1.9GiB uncompressed debug info with LLD, this optimization decreases max RSS by ~1.5GiB.

[MaskRay]

There are very few users of zlib::compress operating on SmallVectorImpl<char>. If the two overloads seem redundant, I can remove the SmallVectorImpl<char> overload in future revision.

[ruiu]

This is very interesting!

include/llvm/Support/Compression.h

36–38

I think you should replace this function entirely with the new one because this is LLVM-only function and you can update all callers.

[MaskRay]

Remove zlib::compress on SmallVectorImpl and change all callers to use std::unique_ptr<uint8_t[]>

[ruiu]

If you are using git-svn, can you combine this patch with your another patch for lld, so that we can review this API-changing patch as one patch?

[ruiu]

lib/Support/Compression.cpp

65

I think you should sync to the head. This line is already gone.

[ruiu]

If you are using git, you can actually combine this patch work your another patch as a single patch.

[MaskRay]

In D50223#1187829, @ruiu wrote:

If you are using git, you can actually combine this patch work your another patch as a single patch.

I use git but not mono-repo git..

git clone https://git.llvm.org/git/llvm.git
cd llvm/tools
git clone https://git.llvm.org/git/clang.git

I cannot combine this with changes in clang.

The change on clang's side is at https://reviews.llvm.org/D50267

[efriedma]

SmallVector has a method set_size to change the size of the vector without initializing the elements; you don't need to switch to unique_ptr just for that.

[MaskRay]

Use set_size

[ruiu]

LGTM

[MaskRay]

Committed in rL338913

This is not closed automatically because I amended the git commit and inserted

Differential Revision: https://reviews.llvm.org/50223  # but I missed a `D` here...

include/llvm/Support/Compression.h

 // This file contains basic functions for compression/uncompression.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_COMPRESSION_H
 #define LLVM_SUPPORT_COMPRESSION_H
 
 #include "llvm/Support/DataTypes.h"
+#include <memory>
 
 namespace llvm {
 template <typename T> class SmallVectorImpl;
 class Error;
 class StringRef;
 
 namespace zlib {
 
 enum CompressionLevel {
   NoCompression,
   DefaultCompression,
   BestSpeedCompression,
   BestSizeCompression
 };
 
 bool isAvailable();
 
-Error compress(StringRef InputBuffer, SmallVectorImpl<char> &CompressedBuffer,
+Error compress(StringRef Input, std::unique_ptr<uint8_t[]> &CompressedData,
+               size_t &CompressedSize,
                CompressionLevel Level = DefaultCompression);
 
 Error uncompress(StringRef InputBuffer, char *UncompressedBuffer,
                  size_t &UncompressedSize);
 
 Error uncompress(StringRef InputBuffer,
                  SmallVectorImpl<char> &UncompressedBuffer,
                  size_t UncompressedSize);
 
 uint32_t crc32(StringRef Buffer);
 
 }  // End of namespace zlib
 
 } // End of namespace llvm
 
 #endif
 

lib/MC/ELFObjectWriter.cpp

struct ELFWriter {
   unsigned addToSectionTable(const MCSectionELF *Sec);
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const;
   bool hasRelocationAddend() const;
 
   void align(unsigned Alignment);
 
-  bool maybeWriteCompression(uint64_t Size,
-                             SmallVectorImpl<char> &CompressedContents,
+  bool maybeWriteCompression(uint64_t Size, size_t CompressedSize,
                              bool ZLibStyle, unsigned Alignment);
 
 public:
   ELFWriter(ELFObjectWriter &OWriter, raw_pwrite_stream &OS,
             bool IsLittleEndian, DwoMode Mode)
       : OWriter(OWriter),
         W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
 
MCSectionELF *RelaSection = Ctx.createELFRelSection(
       RelaSectionName, hasRelocationAddend() ? ELF::SHT_RELA : ELF::SHT_REL,
       Flags, EntrySize, Sec.getGroup(), &Sec);
   RelaSection->setAlignment(is64Bit() ? 8 : 4);
   return RelaSection;
 }
 
 // Include the debug info compression header.
 bool ELFWriter::maybeWriteCompression(
-    uint64_t Size, SmallVectorImpl<char> &CompressedContents, bool ZLibStyle,
+    uint64_t Size, size_t CompressedSize, bool ZLibStyle,
     unsigned Alignment) {
   if (ZLibStyle) {
     uint64_t HdrSize =
         is64Bit() ? sizeof(ELF::Elf32_Chdr) : sizeof(ELF::Elf64_Chdr);
-    if (Size <= HdrSize + CompressedContents.size())
+    if (Size <= HdrSize + CompressedSize)
       return false;
     // Platform specific header is followed by compressed data.
     if (is64Bit()) {
       // Write Elf64_Chdr header.
       write(static_cast<ELF::Elf64_Word>(ELF::ELFCOMPRESS_ZLIB));
       write(static_cast<ELF::Elf64_Word>(0)); // ch_reserved field.
       write(static_cast<ELF::Elf64_Xword>(Size));
       write(static_cast<ELF::Elf64_Xword>(Alignment));
     } else {
       // Write Elf32_Chdr header otherwise.
       write(static_cast<ELF::Elf32_Word>(ELF::ELFCOMPRESS_ZLIB));
       write(static_cast<ELF::Elf32_Word>(Size));
       write(static_cast<ELF::Elf32_Word>(Alignment));
     }
     return true;
   }
 
   // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
   // useful for consumers to preallocate a buffer to decompress into.
   const StringRef Magic = "ZLIB";
-  if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
+  if (Size <= Magic.size() + sizeof(Size) + CompressedSize)
     return false;
   W.OS << Magic;
   support::endian::write(W.OS, Size, support::big);
   return true;
 }
 
 void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
                                  const MCAsmLayout &Layout) {
void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
   assert((MAI->compressDebugSections() == DebugCompressionType::Z ||
           MAI->compressDebugSections() == DebugCompressionType::GNU) &&
          "expected zlib or zlib-gnu style compression");
 
   SmallVector<char, 128> UncompressedData;
   raw_svector_ostream VecOS(UncompressedData);
   Asm.writeSectionData(VecOS, &Section, Layout);
 
-  SmallVector<char, 128> CompressedContents;
+  std::unique_ptr<uint8_t[]> CompressedData;
+  size_t CompressedSize;
   if (Error E = zlib::compress(
           StringRef(UncompressedData.data(), UncompressedData.size()),
-          CompressedContents)) {
+          CompressedData, CompressedSize)) {
     consumeError(std::move(E));
     W.OS << UncompressedData;
     return;
   }
 
   bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
-  if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
-                             ZlibStyle, Sec.getAlignment())) {
+  if (!maybeWriteCompression(UncompressedData.size(), CompressedSize, ZlibStyle,
+                             Sec.getAlignment())) {
     W.OS << UncompressedData;
     return;
   }
 
   if (ZlibStyle)
     // Set the compressed flag. That is zlib style.
     Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
   else
     // Add "z" prefix to section name. This is zlib-gnu style.
     MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str());
-  W.OS << CompressedContents;
+  W.OS << StringRef((char *)CompressedData.get(), CompressedSize);
 }
 
 void ELFWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
                                  uint64_t Address, uint64_t Offset,
                                  uint64_t Size, uint32_t Link, uint32_t Info,
                                  uint64_t Alignment, uint64_t EntrySize) {
   W.write<uint32_t>(Name);        // sh_name: index into string table
   W.write<uint32_t>(Type);        // sh_type

lib/ProfileData/InstrProf.cpp

auto WriteStringToResult = [&](size_t CompressedLen, StringRef InputStr) {
     Result += InputStr;
     return Error::success();
   };
 
   if (!doCompression) {
     return WriteStringToResult(0, UncompressedNameStrings);
   }
 
-  SmallString<128> CompressedNameStrings;
-  Error E = zlib::compress(StringRef(UncompressedNameStrings),
-                           CompressedNameStrings, zlib::BestSizeCompression);
+  std::unique_ptr<uint8_t[]> CompressedNameStrings;
+  size_t CompressedSize;
+  Error E =
+      zlib::compress(StringRef(UncompressedNameStrings), CompressedNameStrings,
+                     CompressedSize, zlib::BestSizeCompression);
   if (E) {
     consumeError(std::move(E));
     return make_error<InstrProfError>(instrprof_error::compress_failed);
   }
 
-  return WriteStringToResult(CompressedNameStrings.size(),
-                             CompressedNameStrings);
+  return WriteStringToResult(
+      CompressedSize,
+      StringRef((char *)CompressedNameStrings.get(), CompressedSize));
 }
 
 StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar) {
   auto *Arr = cast<ConstantDataArray>(NameVar->getInitializer());
   StringRef NameStr =
       Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
   return NameStr;
 }

lib/Support/Compression.cpp

static StringRef convertZlibCodeToString(int Code) {
   case Z_OK:
   default:
     llvm_unreachable("unknown or unexpected zlib status code");
   }
 }
 
 bool zlib::isAvailable() { return true; }
 
-Error zlib::compress(StringRef InputBuffer,
-                     SmallVectorImpl<char> &CompressedBuffer,
-                     CompressionLevel Level) {
-  unsigned long CompressedSize = ::compressBound(InputBuffer.size());
-  CompressedBuffer.resize(CompressedSize);
+Error zlib::compress(StringRef Input,
+                     std::unique_ptr<uint8_t[]> &CompressedData,
+                     size_t &CompressedSize, CompressionLevel Level) {
+  CompressedSize = (size_t)::compressBound(Input.size());
+  CompressedData.reset(new uint8_t[CompressedSize]);
   int CLevel = encodeZlibCompressionLevel(Level);
-  int Res = ::compress2((Bytef *)CompressedBuffer.data(), &CompressedSize,
-                        (const Bytef *)InputBuffer.data(), InputBuffer.size(),
-                        CLevel);
+  int Res = ::compress2(CompressedData.get(), &CompressedSize,
+                        (const Bytef *)Input.data(), Input.size(), CLevel);
   // Tell MemorySanitizer that zlib output buffer is fully initialized.
   // This avoids a false report when running LLVM with uninstrumented ZLib.
-  __msan_unpoison(CompressedBuffer.data(), CompressedSize);
-  CompressedBuffer.resize(CompressedSize);
+  __msan_unpoison(CompressedData.get(), CompressedSize);
   return Res ? createError(convertZlibCodeToString(Res)) : Error::success();
 }
 
 Error zlib::uncompress(StringRef InputBuffer, char *UncompressedBuffer,
                        size_t &UncompressedSize) {
   int Res =
       ::uncompress((Bytef *)UncompressedBuffer, (uLongf *)&UncompressedSize,
                    (const Bytef *)InputBuffer.data(), InputBuffer.size());

unittests/Support/CompressionTest.cpp

 
 using namespace llvm;
 
 namespace {
 
 #if LLVM_ENABLE_ZLIB == 1 && HAVE_LIBZ
 
 void TestZlibCompression(StringRef Input, zlib::CompressionLevel Level) {
-  SmallString<32> Compressed;
+  std::unique_ptr<uint8_t[]> Compressed;
+  size_t CompressedSize;
   SmallString<32> Uncompressed;
 
-  Error E = zlib::compress(Input, Compressed, Level);
+  Error E = zlib::compress(Input, Compressed, CompressedSize, Level);
   EXPECT_FALSE(E);
   consumeError(std::move(E));
 
   // Check that uncompressed buffer is the same as original.
-  E = zlib::uncompress(Compressed, Uncompressed, Input.size());
+  E = zlib::uncompress(StringRef((char *)Compressed.get(), CompressedSize),
+                       Uncompressed, Input.size());
   EXPECT_FALSE(E);
   consumeError(std::move(E));
 
   EXPECT_EQ(Input, Uncompressed);
   if (Input.size() > 0) {
     // Uncompression fails if expected length is too short.
-    E = zlib::uncompress(Compressed, Uncompressed, Input.size() - 1);
+    E = zlib::uncompress(StringRef((char *)Compressed.get(), CompressedSize),
+                         Uncompressed, Input.size() - 1);
     EXPECT_EQ("zlib error: Z_BUF_ERROR", llvm::toString(std::move(E)));
   }
 }
 
 TEST(CompressionTest, Zlib) {
   TestZlibCompression("", zlib::DefaultCompression);
 
   TestZlibCompression("hello, world!", zlib::NoCompression);