[profile] pre-allocate a small counter set in profile runtime

[davidxl]

Summary

vp-counters-per-site tunings for small apps generally works (for SPEC), but gobmk is an outlier. It has ~40 sites with ~800 values collected. Bumping up per-site ratio to 20x can be too excessive for general cases. Here a very low overhead solution is to pre-allocate a shared pool which works well.

I can make it work in a way such that the overhead is only paid with value profiling is on and when dynamic allocation is off. However given that the overhead (24k bytes) is tiny, I would rather avoid it.

[silvas]

This on the order of our statically allocated I/O buffers, so I'm not too worried. LGTM.

compiler-rt/trunk/lib/profile/InstrProfilingValue.c

 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #define INSTR_PROF_VALUE_PROF_DATA
 #define INSTR_PROF_COMMON_API_IMPL
 #include "InstrProfData.inc"
 
+static int hasStaticCounters = 1;
+static int OutOfNodesWarnings = 0;
+static int hasNonDefaultValsPerSite = 0;
+#define INSTR_PROF_MAX_VP_WARNS 10
+#define INSTR_PROF_DEFAULT_NUM_VAL_PER_SITE 8
+#define INSTR_PROF_VNODE_POOL_SIZE 1024
+
+/* A shared static pool in addition to the vnodes statically
+ * allocated by the compiler.  */
+COMPILER_RT_VISIBILITY ValueProfNode
+    lprofValueProfNodes[INSTR_PROF_VNODE_POOL_SIZE] COMPILER_RT_SECTION(
+        INSTR_PROF_VNODES_SECT_NAME_STR);
+
 COMPILER_RT_VISIBILITY uint32_t VPMaxNumValsPerSite =
-    INSTR_PROF_MAX_NUM_VAL_PER_SITE;
+    INSTR_PROF_DEFAULT_NUM_VAL_PER_SITE;
 
 COMPILER_RT_VISIBILITY void lprofSetupValueProfiler() {
   const char *Str = 0;
   Str = getenv("LLVM_VP_MAX_NUM_VALS_PER_SITE");
-  if (Str && Str[0])
+  if (Str && Str[0]) {
     VPMaxNumValsPerSite = atoi(Str);
+    hasNonDefaultValsPerSite = 1;
+  }
   if (VPMaxNumValsPerSite > INSTR_PROF_MAX_NUM_VAL_PER_SITE)
     VPMaxNumValsPerSite = INSTR_PROF_MAX_NUM_VAL_PER_SITE;
-
-  if (!(EndVNode > CurrentVNode)) {
-    CurrentVNode = 0;
-    EndVNode = 0;
-  }
-  /* Adjust max vals per site to a smaller value
-   * when static allocation is in use. */
-  else {
-    if (!Str || !Str[0])
-      VPMaxNumValsPerSite = 8;
-  }
 }
 
 COMPILER_RT_VISIBILITY void lprofSetMaxValsPerSite(uint32_t MaxVals) {
   VPMaxNumValsPerSite = MaxVals;
+  hasNonDefaultValsPerSite = 1;
 }
 
 /* This method is only used in value profiler mock testing.  */
 COMPILER_RT_VISIBILITY void
 __llvm_profile_set_num_value_sites(__llvm_profile_data *Data,
                                    uint32_t ValueKind, uint16_t NumValueSites) {
   *((uint16_t *)&Data->NumValueSites[ValueKind]) = NumValueSites;
 }

 }
 
 /* Allocate an array that holds the pointers to the linked lists of
  * value profile counter nodes. The number of element of the array
  * is the total number of value profile sites instrumented. Returns
  * 0 if allocation fails.
  */
 
-static int hasStaticCounters = 1;
-static int OutOfNodesWarnings = 0;
-#define MAX_VP_WARNS 10
-
 static int allocateValueProfileCounters(__llvm_profile_data *Data) {
   uint64_t NumVSites = 0;
   uint32_t VKI;
 
   /* This function will never be called when value site array is allocated
      statically at compile time.  */
   hasStaticCounters = 0;
+  /* When dynamic allocation is enabled, allow tracking the max number of
+   * values allowd.  */
+  if (!hasNonDefaultValsPerSite)
+    VPMaxNumValsPerSite = INSTR_PROF_MAX_NUM_VAL_PER_SITE;
 
   for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
     NumVSites += Data->NumValueSites[VKI];
 
   ValueProfNode **Mem =
       (ValueProfNode **)calloc(NumVSites, sizeof(ValueProfNode *));
   if (!Mem)
     return 0;
   if (!COMPILER_RT_BOOL_CMPXCHG(&Data->Values, 0, Mem)) {
     free(Mem);
     return 0;
   }
   return 1;
 }
 
 static ValueProfNode *allocateOneNode(__llvm_profile_data *Data, uint32_t Index,
                                       uint64_t Value) {
   ValueProfNode *Node;
 
   if (!hasStaticCounters)
     return (ValueProfNode *)calloc(1, sizeof(ValueProfNode));
 
   /* Early check to avoid value wrapping around.  */
   if (CurrentVNode >= EndVNode) {
-    if (OutOfNodesWarnings++ < MAX_VP_WARNS) {
+    if (OutOfNodesWarnings++ < INSTR_PROF_MAX_VP_WARNS) {
       PROF_WARN("Unable to track new values: %s. "
                 " Consider using option -mllvm -vp-counters-per-site=<n> to "
                 "allocate more"
                 " value profile counters at compile time. \n",
                 "Running out of static counters");
     }
     return 0;
   }