[PoC] llvm-profdata - Normalize the PGO data before writing them to disk

[sebmarchand]

Summary

Proof of concept, not meant to be committed.

llvm/include/llvm/ProfileData/InstrProf.h

struct InstrProfRecord {
   void overlap(InstrProfRecord &Other, OverlapStats &Overlap,
                OverlapStats &FuncLevelOverlap, uint64_t ValueCutoff);
 
   /// Compute the overlap of value profile counts.
   void overlapValueProfData(uint32_t ValueKind, InstrProfRecord &Src,
                             OverlapStats &Overlap,
                             OverlapStats &FuncLevelOverlap);
 
+  void normalizeData(uint64_t MinValue, bool ClampToPow2);
+
 private:
   struct ValueProfData {
     std::vector<InstrProfValueSiteRecord> IndirectCallSites;
     std::vector<InstrProfValueSiteRecord> MemOPSizes;
   };
   std::unique_ptr<ValueProfData> ValueData;
 
   MutableArrayRef<InstrProfValueSiteRecord>

llvm/include/llvm/ProfileData/InstrProfWriter.h

public:
   void setValueProfDataEndianness(support::endianness Endianness);
   void setOutputSparse(bool Sparse);
   // Compute the overlap b/w this object and Other. Program level result is
   // stored in Overlap and function level result is stored in FuncLevelOverlap.
   void overlapRecord(NamedInstrProfRecord &&Other, OverlapStats &Overlap,
                      OverlapStats &FuncLevelOverlap,
                      const OverlapFuncFilters &FuncFilter);
 
+  void normalizeData(uint64_t MinValue, bool ClampToPow2);
+
 private:
   void addRecord(StringRef Name, uint64_t Hash, InstrProfRecord &&I,
                  uint64_t Weight, function_ref<void(Error)> Warn);
   bool shouldEncodeData(const ProfilingData &PD);
   void writeImpl(ProfOStream &OS);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFWRITER_H

llvm/lib/ProfileData/InstrProf.cpp

std::vector<InstrProfValueSiteRecord> &ThisSiteRecords =
       getOrCreateValueSitesForKind(ValueKind);
   MutableArrayRef<InstrProfValueSiteRecord> OtherSiteRecords =
       Other.getValueSitesForKind(ValueKind);
   for (uint32_t I = 0; I < ThisNumValueSites; I++)
     ThisSiteRecords[I].overlap(OtherSiteRecords[I], ValueKind, Overlap,
                                FuncLevelOverlap);
 }
 
+void InstrProfRecord::normalizeData(uint64_t MinValue, bool ClampToPow2) {
+  for (auto& counter : Counts) {
+    if (counter < MinValue)
+      counter = 0;
+    else if (ClampToPow2)
+      counter = std::pow(2, std::floor(std::log2(counter)));
+  }
+}
+
 void InstrProfRecord::overlap(InstrProfRecord &Other, OverlapStats &Overlap,
                               OverlapStats &FuncLevelOverlap,
                               uint64_t ValueCutoff) {
   // FuncLevel CountSum for other should already computed and nonzero.
   assert(FuncLevelOverlap.Test.CountSum >= 1.0f);
   accumulateCounts(FuncLevelOverlap.Base);
   bool Mismatch = (Counts.size() != Other.Counts.size());
 

llvm/lib/ProfileData/InstrProfWriter.cpp

void InstrProfWriter::overlapRecord(NamedInstrProfRecord &&Other,
   uint64_t ValueCutoff = FuncFilter.ValueCutoff;
   if (!FuncFilter.NameFilter.empty() &&
       Name.find(FuncFilter.NameFilter) != Name.npos)
     ValueCutoff = 0;
 
   Dest.overlap(Other, Overlap, FuncLevelOverlap, ValueCutoff);
 }
 
+void InstrProfWriter::normalizeData(uint64_t MinValue, bool ClampToPow2) {
+  for (auto& F : FunctionData)
+    for (auto& I : F.getValue()) {
+      I.getSecond().normalizeData(MinValue, ClampToPow2);
+  }
+}
+
 void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
                                 InstrProfRecord &&I, uint64_t Weight,
                                 function_ref<void(Error)> Warn) {
   auto &ProfileDataMap = FunctionData[Name];
 
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =

llvm/tools/llvm-profdata/llvm-profdata.cpp

if (NumErrors == Inputs.size() ||
     exitWithError("No profiles could be merged.");
 
   std::error_code EC;
   raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::OF_None);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   InstrProfWriter &Writer = Contexts[0]->Writer;
+  Writer.normalizeData(20, true);
   if (OutputFormat == PF_Text) {
     if (Error E = Writer.writeText(Output))
       exitWithError(std::move(E));
   } else {
     Writer.write(Output);
   }
 }
 

llvm/utils/gn/build/libs/zlib/BUILD.gn

 import("//llvm/utils/gn/build/libs/zlib/enable.gni")
 
 config("zlib_config") {
   visibility = [ ":zlib" ]
+  if (host_os == "win") {
+    include_dirs = [ "C:\\src\\chrome\\src\\third_party\\llvm-build-tools\\zlib-1.2.11" ]
+    libs = [ "C:\\src\\chrome\\src\\third_party\\llvm-build-tools\\zlib-1.2.11\\zlib.lib" ]
+  } else {
     libs = [ "z" ]
   }
+}
 
 group("zlib") {
   if (llvm_enable_zlib) {
     public_configs = [ ":zlib_config" ]
   }
 }

llvm/utils/gn/secondary/llvm/include/llvm/Config/BUILD.gn

values += [
       "HAVE_DLOPEN=",
       "HAVE_FUTIMES=",
       "HAVE_GETPAGESIZE=",
       "HAVE_GETRLIMIT=",
       "HAVE_GETRUSAGE=",
       "HAVE_ISATTY=",
       "HAVE_LIBPTHREAD=",
       "HAVE_PTHREAD_SETNAME_NP=",
-      "HAVE_LIBZ=",
+      "HAVE_LIBZ=1",
       "HAVE_PREAD=",
       "HAVE_PTHREAD_GETSPECIFIC=",
       "HAVE_PTHREAD_H=",
       "HAVE_PTHREAD_MUTEX_LOCK=",
       "HAVE_PTHREAD_RWLOCK_INIT=",
       "HAVE_SBRK=",
       "HAVE_SETENV=",
       "HAVE_SETRLIMIT=",
       "HAVE_SIGALTSTACK=",
       "HAVE_STRERROR_R=",
       "HAVE_SYSCONF=",
       "HAVE_SYS_IOCTL_H=",
       "HAVE_SYS_MMAN_H=",
       "HAVE_SYS_PARAM_H=",
       "HAVE_SYS_RESOURCE_H=",
       "HAVE_SYS_TIME_H=",
       "HAVE_TERMIOS_H=",
       "HAVE_UNISTD_H=",
-      "HAVE_ZLIB_H=",
+      "HAVE_ZLIB_H=1",
       "HAVE__CHSIZE_S=1",
       "HAVE__UNWIND_BACKTRACE=",
       "stricmp=_stricmp",
       "strdup=_strdup",
     ]
   } else {
     # POSIX-y system defaults.
     values += [