[esan] Add __esan_report for mid-run data

[bruening]

Summary

Adds a new public interface routine __esan_report() which can be used to
request profiling results prior to abnormal termination (e.g., for a server
process killed by its parent where the normal exit does not allow for
normal result reporting).

Implements this for the working-set tool. The cache frag tool is left
unimplemented as it requires missing iteration capabilities.

Adds a new test.

[aizatsky]

include/sanitizer/esan_interface.h

26 ↗

(On Diff #63087)

do you want this to be weak so that host program could be compiled without esan as well?
Or do you plan to have ifdefs in the host?

lib/esan/esan.cpp

236 ↗

(On Diff #63087)

Do you think it makes sense to have classes with virtual methods now?

All these functions perform tool-based dispatch.

lib/esan/working_set.cpp

121 ↗

(On Diff #63087)

can you explain why is this a desired behavior? It is not clear to me :)

Maybe making it caller's responsibility is better?

countAndClearShadowValues(u32 BitIdx, uptr ShadowStart,

uptr ShadowEnd, bool ClearBits)

[bruening]

include/sanitizer/esan_interface.h

26 ↗

(On Diff #63087)

I don't see how it can work without ifdefs simply by being weak? If it's weak and the esan library is not linked in, the caller's call to esan_report() will be a call to NULL and will crash. To avoid that, the caller would have to provide an empty-body implementation of esan_report that was also weak, and we'd have to hope that the esan library's version was found first. I don't see any use of weak in the other *san_interface.h headers and I assume they all rely on ifdefs in the caller -- right? Or am I missing something?

lib/esan/esan.cpp

236 ↗

(On Diff #63087)

That is something we have considered and should probably do at some point, but as a separate refactoring from this CL. We'll put it on our short list for improving the code.

lib/esan/working_set.cpp

121 ↗

(On Diff #63087)

We only want to clear bits that are measuring just part of the execution: one time period. The top bit is measuring the entire execution, so it's special, and should never be cleared. In the past we only ever called this routine for the top bit at the very end of the run to report the total, but with this new mid-run report we're calling this at arbitrary times and thus need to avoid the clear.

[aizatsky]

include/sanitizer/esan_interface.h

26 ↗

(On Diff #63087)

No, with weak function the caller could be written as:

if (esan_report)

esan_report();

And compile/link/run fine with and without esan and without the use of preprocessor.

lib/esan/working_set.cpp

121 ↗

(On Diff #63087)

If you could put this into one-line comment next to clear that would be awesome.

// high bit measure access during entire execution, should never be cleared.

[bruening]

include/sanitizer/esan_interface.h

26 ↗

(On Diff #63087)

Right, that would work. I don't see any precedent for this, as no other sanitizer does it in their public interfaces, but I don't see any downside to making it weak (unintended symbol collision is quite unlikely) so I'll go ahead and do so.

lib/esan/working_set.cpp

121 ↗

(On Diff #63087)

Will do.

compiler-rt/trunk/include/CMakeLists.txt

 set(SANITIZER_HEADERS
   sanitizer/allocator_interface.h
   sanitizer/asan_interface.h
   sanitizer/common_interface_defs.h
   sanitizer/coverage_interface.h
   sanitizer/dfsan_interface.h
+  sanitizer/esan_interface.h
   sanitizer/linux_syscall_hooks.h
   sanitizer/lsan_interface.h
   sanitizer/msan_interface.h
   sanitizer/tsan_interface_atomic.h)
 
 set(output_dir ${COMPILER_RT_OUTPUT_DIR}/include)
 
 # Copy compiler-rt headers to the build tree.

compiler-rt/trunk/include/sanitizer/esan_interface.h

+//===-- sanitizer/esan_interface.h ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of EfficiencySanitizer, a family of performance tuners.
+//
+// Public interface header.
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_ESAN_INTERFACE_H
+#define SANITIZER_ESAN_INTERFACE_H
+
+#include <sanitizer/common_interface_defs.h>
+
+// We declare our interface routines as weak to allow the user to avoid
+// ifdefs and instead use this pattern to allow building the same sources
+// with and without our runtime library:
+//     if (__esan_report)
+//       __esan_report();
+#ifdef _MSC_VER
+/* selectany is as close to weak as we'll get. */
+#define COMPILER_RT_WEAK __declspec(selectany)
+#elif __GNUC__
+#define COMPILER_RT_WEAK __attribute__((weak))
+#else
+#define COMPILER_RT_WEAK
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This function can be called mid-run (or at the end of a run for
+// a server process that doesn't shut down normally) to request that
+// data for that point in the run be reported from the tool.
+void COMPILER_RT_WEAK __esan_report();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SANITIZER_ESAN_INTERFACE_H

compiler-rt/trunk/lib/esan/cache_frag.h

 
 namespace __esan {
 
 void processCacheFragCompilationUnitInit(void *Ptr);
 void processCacheFragCompilationUnitExit(void *Ptr);
 
 void initializeCacheFrag();
 int finalizeCacheFrag();
+void reportCacheFrag();
 
 } // namespace __esan
 
 #endif  // CACHE_FRAG_H

compiler-rt/trunk/lib/esan/cache_frag.cpp

void initializeCacheFrag() {
   Ctx->NumStructs = 0;
 }
 
 int finalizeCacheFrag() {
   VPrintf(2, "in esan::%s\n", __FUNCTION__);
   return 0;
 }
 
+void reportCacheFrag() {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+  // FIXME: Not yet implemented.  We need to iterate over all of the
+  // compilation unit data.
+}
+
 } // namespace __esan

compiler-rt/trunk/lib/esan/esan.h

 
 namespace __esan {
 
 extern bool EsanIsInitialized;
 extern bool EsanDuringInit;
 
 void initializeLibrary(ToolType Tool);
 int finalizeLibrary();
+void reportResults();
 // Esan creates the variable per tool per compilation unit at compile time
 // and passes its pointer Ptr to the runtime library.
 void processCompilationUnitInit(void *Ptr);
 void processCompilationUnitExit(void *Ptr);
 void processRangeAccess(uptr PC, uptr Addr, int Size, bool IsWrite);
 void initializeInterceptors();
 
 // Platform-dependent routines.

compiler-rt/trunk/lib/esan/esan.cpp

int finalizeLibrary() {
   if (__esan_which_tool == ESAN_CacheFrag) {
     return finalizeCacheFrag();
   } else if (__esan_which_tool == ESAN_WorkingSet) {
     return finalizeWorkingSet();
   }
   return 0;
 }
 
+void reportResults() {
+  VPrintf(1, "in esan::%s\n", __FUNCTION__);
+  if (__esan_which_tool == ESAN_CacheFrag) {
+    return reportCacheFrag();
+  } else if (__esan_which_tool == ESAN_WorkingSet) {
+    return reportWorkingSet();
+  }
+}
+
 void processCompilationUnitInit(void *Ptr) {
   VPrintf(2, "in esan::%s\n", __FUNCTION__);
   if (__esan_which_tool == ESAN_CacheFrag) {
     DCHECK(Ptr != nullptr);
     processCacheFragCompilationUnitInit(Ptr);
   } else {
     DCHECK(Ptr == nullptr);
   }

compiler-rt/trunk/lib/esan/esan_interface.cpp

 
 void __esan_unaligned_loadN(void *Addr, uptr Size) {
   processRangeAccess(GET_CALLER_PC(), (uptr)Addr, Size, false);
 }
 
 void __esan_unaligned_storeN(void *Addr, uptr Size) {
   processRangeAccess(GET_CALLER_PC(), (uptr)Addr, Size, true);
 }
+
+// Public interface:
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_report() {
+  reportResults();
+}
+} // extern "C"

compiler-rt/trunk/lib/esan/working_set.h

 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 
 namespace __esan {
 
 void initializeWorkingSet();
 void initializeShadowWorkingSet();
 int finalizeWorkingSet();
+void reportWorkingSet();
 void processRangeAccessWorkingSet(uptr PC, uptr Addr, SIZE_T Size,
                                   bool IsWrite);
 
 // Platform-dependent.
 void registerMemoryFaultHandler();
 bool processWorkingSetSignal(int SigNum, void (*Handler)(int),
                              void (**Result)(int));
 bool processWorkingSetSigaction(int SigNum, const void *Act, void *OldAct);
 bool processWorkingSetSigprocmask(int How, void *Set, void *OldSet);
 
 } // namespace __esan
 
 #endif // WORKING_SET_H

compiler-rt/trunk/lib/esan/working_set.cpp

while (I < NumLines) {
     if ((*Shadow & ShadowAccessedVal) != ShadowAccessedVal)
       *Shadow |= ShadowAccessedVal;
     ++Shadow;
     ++I;
   }
 }
 
 // This routine will word-align ShadowStart and ShadowEnd prior to scanning.
+// It does *not* clear for BitIdx==TotalWorkingSetBitIdx, as that top bit
+// measures the access during the entire execution and should never be cleared.
 static u32 countAndClearShadowValues(u32 BitIdx, uptr ShadowStart,
                                      uptr ShadowEnd) {
   u32 WorkingSetSize = 0;
   u32 ByteValue = 0x1 << BitIdx;
   u32 WordValue = ByteValue | ByteValue << 8 | ByteValue << 16 |
     ByteValue << 24;
   // Get word aligned start.
   ShadowStart = RoundDownTo(ShadowStart, sizeof(u32));
   bool Accum = getFlags()->record_snapshots && BitIdx < MaxAccumBitIdx;
+  // Do not clear the bit that measures access during the entire execution.
+  bool Clear = BitIdx < TotalWorkingSetBitIdx;
   for (u32 *Ptr = (u32 *)ShadowStart; Ptr < (u32 *)ShadowEnd; ++Ptr) {
     if ((*Ptr & WordValue) != 0) {
       byte *BytePtr = (byte *)Ptr;
       for (u32 j = 0; j < sizeof(u32); ++j) {
         if (BytePtr[j] & ByteValue) {
           ++WorkingSetSize;
           if (Accum) {
             // Accumulate to the lower-frequency bit to the left.
             BytePtr[j] |= (ByteValue << 1);
           }
         }
       }
+      if (Clear) {
         // Clear this bit from every shadow byte.
         *Ptr &= ~WordValue;
       }
     }
+  }
   return WorkingSetSize;
 }
 
 // Scan shadow memory to calculate the number of cache lines being accessed,
 // i.e., the number of non-zero bits indexed by BitIdx in each shadow byte.
 // We also clear the lowest bits (most recent working set snapshot).
+// We do *not* clear for BitIdx==TotalWorkingSetBitIdx, as that top bit
+// measures the access during the entire execution and should never be cleared.
 static u32 computeWorkingSizeAndReset(u32 BitIdx) {
   u32 WorkingSetSize = 0;
   MemoryMappingLayout MemIter(true/*cache*/);
   uptr Start, End, Prot;
   while (MemIter.Next(&Start, &End, nullptr/*offs*/, nullptr/*file*/,
                       0/*file size*/, &Prot)) {
     VPrintf(4, "%s: considering %p-%p app=%d shadow=%d prot=%u\n",
             __FUNCTION__, Start, End, Prot, isAppMem(Start),
if (NumOfCachelines > 10 * MegabyteCachelines) {
     Unit = "KB";
     return NumOfCachelines / KilobyteCachelines;
   } else {
     Unit = "Bytes";
     return NumOfCachelines * CacheLineSize;
   }
 }
 
-int finalizeWorkingSet() {
+void reportWorkingSet() {
   const char *Unit;
   if (getFlags()->record_snapshots) {
-    Thread.joinThread();
     u32 Freq = 1;
     Report(" Total number of samples: %u\n", SnapshotNum);
     for (u32 i = 0; i < NumFreq; ++i) {
       u32 Time = getPeriodForPrinting(getFlags()->sample_freq*Freq, Unit);
       Report(" Samples array #%d at period %u %s\n", i, Time, Unit);
       // FIXME: report whether we wrapped around and thus whether we
       // have data on the whole run or just the last N samples.
       for (u32 j = 0; j < SizePerFreq[i].size(); ++j) {
         u32 Size = getSizeForPrinting(SizePerFreq[i][j], Unit);
         Report("#%4d: %8u %s (%9u cache lines)\n", j, Size, Unit,
                SizePerFreq[i][j]);
       }
       Freq = Freq << getFlags()->snapshot_step;
-      SizePerFreq[i].free();
     }
   }
 
   // Get the working set size for the entire execution.
   u32 NumOfCachelines = computeWorkingSizeAndReset(TotalWorkingSetBitIdx);
   u32 Size = getSizeForPrinting(NumOfCachelines, Unit);
   Report(" %s: the total working set size: %u %s (%u cache lines)\n",
          SanitizerToolName, Size, Unit, NumOfCachelines);
+}
+
+int finalizeWorkingSet() {
+  if (getFlags()->record_snapshots)
+    Thread.joinThread();
+  reportWorkingSet();
+  if (getFlags()->record_snapshots) {
+    for (u32 i = 0; i < NumFreq; ++i)
+      SizePerFreq[i].free();
+  }
   return 0;
 }
 
 } // namespace __esan

compiler-rt/trunk/test/esan/TestCases/workingset-midreport.cpp

+// RUN: %clang_esan_wset -O0 %s -o %t 2>&1
+// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ESAN
+
+// RUN: %clang -O0 %s -o %t 2>&1
+// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NO-ESAN
+
+#include <sanitizer/esan_interface.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+
+const int size = 0x1 << 25; // 523288 cache lines
+const int iters = 6;
+
+int main(int argc, char **argv) {
+  char *buf = (char *)mmap(0, size, PROT_READ | PROT_WRITE,
+                           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  // Try to increase the probability that the sideline thread is
+  // scheduled.  Unfortunately we can't do proper synchronization
+  // without some form of annotation or something.
+  sched_yield();
+  // Do enough work to get at least 4 samples.
+  for (int j = 0; j < iters; ++j) {
+    for (int i = 0; i < size; ++i)
+      buf[i] = i;
+    sched_yield();
+  }
+  // Ensure a non-esan build works without ifdefs:
+  if (__esan_report) {
+    // We should get 2 roughly identical reports:
+    __esan_report();
+  }
+  munmap(buf, size);
+  fprintf(stderr, "all done\n");
+  // CHECK-NO-ESAN:   all done
+  // We only check for a few samples here to reduce the chance of flakiness:
+  // CHECK-ESAN:      =={{[0-9]+}}== Total number of samples: {{[0-9]+}}
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}== Samples array #0 at period 20 ms
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   0: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   1: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   2: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   3: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #1 at period 80 ms
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   0: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #2 at period 320 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #3 at period 1280 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #4 at period 5120 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #5 at period 20 sec
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #6 at period 81 sec
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #7 at period 327 sec
+  // CHECK-ESAN: {{.*}} EfficiencySanitizer: the total working set size: 32 MB (5242{{[0-9][0-9]}} cache lines)
+  // CHECK-ESAN-NEXT: all done
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}== Total number of samples: {{[0-9]+}}
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}== Samples array #0 at period 20 ms
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   0: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   1: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   2: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   3: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #1 at period 80 ms
+  // CHECK-ESAN-NEXT: =={{[0-9]+}}==#   0: {{[ 0-9]+}} {{KB|MB|Bytes}} ({{[ 0-9]+}} cache lines)
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #2 at period 320 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #3 at period 1280 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #4 at period 5120 ms
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #5 at period 20 sec
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #6 at period 81 sec
+  // CHECK-ESAN:      =={{[0-9]+}}== Samples array #7 at period 327 sec
+  // CHECK-ESAN: {{.*}} EfficiencySanitizer: the total working set size: 32 MB (5242{{[0-9][0-9]}} cache lines)
+  return 0;
+}

compiler-rt/trunk/test/esan/lit.cfg

 unit_cxxflags = (["-I%s" % esan_incdir, "-std=c++11",
                   # We need to link with the esan runtime.
                   # Tests should pass %env_esan_opts="record_snapshots=0".
                   "-fsanitize=efficiency-working-set"] + base_cxxflags)
 
 def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
+config.substitutions.append( ("%clang ",
+                              build_invocation(base_cflags)) )
 config.substitutions.append( ("%clang_esan_frag ",
                               build_invocation(frag_cflags)) )
 config.substitutions.append( ("%clang_esan_wset ",
                               build_invocation(wset_cflags)) )
 config.substitutions.append( ("%clangxx_unit",
                               build_invocation(unit_cxxflags)) )
 
 default_esan_opts = ''