[esan][cfrag] Add skeleton for cache fragmentation tool support

[zhaoqin]

Summary

Adds cache_frag.h and cache_frag.cpp for the cache fragmentation tool.

Updates test struct-simple.cpp.

[bruening]

Adds cache_frag.h and cache_frag.cpp for the cache fragmetation tool.

spelling: "fragmetation"

Also I would suggest something more high-level than file names in the title.

[filcab]

Please write something describing why you're adding this, instead of file names.
"Adds skeleton for cache fragmentation tool support" or something. No need to be too fancy anyway. :-)

Thank you,

Filipe

[zhaoqin]

updated commit msg.

[zhaoqin]

Merge to top of trunk.

[filcab]

LGTM.

lib/esan/CMakeLists.txt

 # Build for the EfficiencySanitizer runtime support library.
 
 add_custom_target(esan)
 
 set(ESAN_RTL_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF ESAN_RTL_CFLAGS)
 
 include_directories(..)
 
 set(ESAN_SOURCES
   esan.cpp
   esan_flags.cpp
   esan_interface.cpp
   esan_interceptors.cpp
+  cache_frag.cpp
   working_set.cpp)
 
 foreach (arch ${ESAN_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.esan
     STATIC
     ARCHS ${arch}
     SOURCES ${ESAN_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>

lib/esan/cache_frag.h

+//===-- cache_frag.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.
+//
+// Header for cache-fragmentation-specific code.
+//===----------------------------------------------------------------------===//
+
+#ifndef CACHE_FRAG_H
+#define CACHE_FRAG_H
+
+namespace __esan {
+
+void processCacheFragCompilationUnitInit(void *Ptr);
+void processCacheFragCompilationUnitExit(void *Ptr);
+
+void initializeCacheFrag();
+int finalizeCacheFrag();
+
+} // namespace __esan
+
+#endif  // CACHE_FRAG_H

lib/esan/cache_frag.cpp

+//===-- cache_frag.cpp ----------------------------------------------------===//
+//
+//                     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.
+//
+// This file contains cache fragmentation-specific code.
+//===----------------------------------------------------------------------===//
+
+#include "esan.h"
+
+namespace __esan {
+
+//===-- Init/exit functions -----------------------------------------------===//
+
+void processCacheFragCompilationUnitInit(void *Ptr) {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+}
+
+void processCacheFragCompilationUnitExit(void *Ptr) {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+}
+
+void initializeCacheFrag() {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+}
+
+int finalizeCacheFrag() {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+  // FIXME: add the cache fragmentation final report.
+  Report("%s is not finished: nothing yet to report\n", SanitizerToolName);
+  return 0;
+}
+
+} // namespace __esan

lib/esan/esan.cpp

 //
 // Main file (entry points) for the Esan run-time.
 //===----------------------------------------------------------------------===//
 
 #include "esan.h"
 #include "esan_flags.h"
 #include "esan_interface_internal.h"
 #include "esan_shadow.h"
+#include "cache_frag.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "working_set.h"
 
 // See comment below.
 extern "C" {
 extern void __cxa_atexit(void (*function)(void));
if (WhichTool <= ESAN_None || WhichTool >= ESAN_Max) {
     Printf("ERROR: unknown tool %d requested\n", WhichTool);
     Die();
   }
 
   initializeShadow();
   initializeInterceptors();
 
   if (WhichTool == ESAN_CacheFrag) {
-    // FIXME: add runtime code for this tool
+    initializeCacheFrag();
   } else if (WhichTool == ESAN_WorkingSet) {
     initializeWorkingSet();
   }
 
   EsanIsInitialized = true;
 }
 
 int finalizeLibrary() {
   VPrintf(1, "in esan::%s\n", __FUNCTION__);
   if (WhichTool == ESAN_CacheFrag) {
-    // FIXME NYI: we need to add sampling + callstack gathering and have a
-    // strategy for how to generate a final report.
-    // We'll move this to cache_frag.cpp once we have something.
-    Report("%s is not finished: nothing yet to report\n", SanitizerToolName);
+    return finalizeCacheFrag();
   } else if (WhichTool == ESAN_WorkingSet) {
     return finalizeWorkingSet();
   }
   return 0;
 }
 
 void processCompilationUnitInit(void *Ptr) {
   VPrintf(2, "in esan::%s\n", __FUNCTION__);
+  if (WhichTool == ESAN_CacheFrag) {
+    processCacheFragCompilationUnitInit(Ptr);
+  }
 }
 
 // This is called when the containing module is unloaded.
 // For the main executable module, this is called after finalizeLibrary.
 void processCompilationUnitExit(void *Ptr) {
   VPrintf(2, "in esan::%s\n", __FUNCTION__);
+  if (WhichTool == ESAN_CacheFrag) {
+    processCacheFragCompilationUnitExit(Ptr);
+  }
 }
 
 } // namespace __esan

test/esan/TestCases/struct-simple.cpp

 }
 #endif // PART
 
 //===-- compilation unit with main function -------------------------------===//
 
 #ifdef MAIN
 int main(int argc, char **argv) {
   // CHECK:      in esan::initializeLibrary
-  // CHECK:      in esan::processCompilationUnitInit
-  // CHECK:      in esan::processCompilationUnitInit
+  // CHECK:      in esan::initializeCacheFrag
+  // CHECK-NEXT: in esan::processCompilationUnitInit
+  // CHECK-NEXT: in esan::processCacheFragCompilationUnitInit
+  // CHECK-NEXT: in esan::processCompilationUnitInit
+  // CHECK-NEXT: in esan::processCacheFragCompilationUnitInit
   part();
   return 0;
-  // CHECK-NEXT: in esan::finalizeLibrary
+  // CHECK:      in esan::finalizeLibrary
+  // CHECK-NEXT: in esan::finalizeCacheFrag
   // CHECK-NEXT: {{.*}}EfficiencySanitizer is not finished: nothing yet to report
-  // CHECK:      in esan::processCompilationUnitExit
-  // CHECK:      in esan::processCompilationUnitExit
+  // CHECK-NEXT: in esan::processCompilationUnitExit
+  // CHECK-NEXT: in esan::processCacheFragCompilationUnitExit
+  // CHECK-NEXT: in esan::processCompilationUnitExit
+  // CHECK-NEXT: in esan::processCacheFragCompilationUnitExit
 }
 #endif // MAIN