V8ScriptRunner: Add "V8.CompileHeuristicsDecision" UMA

This CL introduces "V8.CompileHeuristicsDecision" which records
which of the script compilation function got picked, providing more insights
about how often V8 {code,parser} cache is {produced,consumed,bypassed}.

Bug: 769203
Change-Id: I7b27a1634ee5b1623330acae1ef27bc78f39742e
Reviewed-on: https://chromium-review.googlesource.com/720660Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Alexei Svitkine <asvitkine@chromium.org>
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Kouhei Ueno <kouhei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#509540}

third_party/WebKit/Source/bindings/core/v8/V8ScriptRunner.cpp

@@ -68,6 +68,7 @@ const int kMaxRecursionDepth = 44;
 class V8CompileHistogram {
  public:
   enum Cacheability { kCacheable, kNoncacheable, kInlineScript };
+
   explicit V8CompileHistogram(Cacheability);
   ~V8CompileHistogram();
 
@@ -108,6 +109,28 @@ V8CompileHistogram::~V8CompileHistogram() {
   }
 }
 
+// Used for UMAs. Don't reorder. New values should be appended.
+enum class CompileHeuristicsDecision {
+  kNoCacheHandler = 0,
+  kCachingDisabled,
+  kCodeTooShortToCache,
+  kCacheTooCold,
+  kProduceParserCache,
+  kConsumeParserCache,
+  kConsumeCodeCache,
+  kProduceCodeCache,
+  kStreamingCompile,
+  kEnumMax
+};
+
+void ReportCompileHeuristicsHistogram(CompileHeuristicsDecision decision) {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(
+      EnumerationHistogram, compile_heuristics_histogram,
+      ("V8.CompileHeuristicsDecision",
+       static_cast<int>(CompileHeuristicsDecision::kEnumMax)));
+  compile_heuristics_histogram.Count(static_cast<int>(decision));
+}
+
 // In order to make sure all pending messages to be processed in
 // v8::Function::Call, we don't call throwStackOverflowException
 // directly. Instead, we create a v8::Function of
@@ -315,16 +338,25 @@ static CompileFn SelectCompileFunction(
   static const int kHotHours = 72;
 
   // Caching is not available in this case.
-  if (!cache_handler)
+  if (!cache_handler) {
+    ReportCompileHeuristicsHistogram(
+        CompileHeuristicsDecision::kNoCacheHandler);
     return WTF::Bind(CompileWithoutOptions, cacheability_if_no_handler);
+  }
 
-  if (cache_options == kV8CacheOptionsNone)
+  if (cache_options == kV8CacheOptionsNone) {
+    ReportCompileHeuristicsHistogram(
+        CompileHeuristicsDecision::kCachingDisabled);
     return WTF::Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable);
+  }
 
   // Caching is not worthwhile for small scripts.  Do not use caching
   // unless explicitly expected, indicated by the cache option.
-  if (code->Length() < kMinimalCodeLength)
+  if (code->Length() < kMinimalCodeLength) {
+    ReportCompileHeuristicsHistogram(
+        CompileHeuristicsDecision::kCodeTooShortToCache);
     return WTF::Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable);
+  }
 
   // The cacheOptions will guide our strategy:
   switch (cache_options) {
@@ -335,14 +367,17 @@ static CompileFn SelectCompileFunction(
           cache_handler ? cache_handler->GetCachedMetadata(parser_tag)
                         : nullptr);
       if (parser_cache) {
+        ReportCompileHeuristicsHistogram(
+            CompileHeuristicsDecision::kProduceParserCache);
         return WTF::Bind(CompileAndConsumeCache, WrapPersistent(cache_handler),
                          std::move(parser_cache),
                          v8::ScriptCompiler::kConsumeParserCache);
       }
+      ReportCompileHeuristicsHistogram(
+          CompileHeuristicsDecision::kConsumeParserCache);
       return WTF::Bind(CompileAndProduceCache, WrapPersistent(cache_handler),
                        parser_tag, v8::ScriptCompiler::kProduceParserCache,
                        CachedMetadataHandler::kCacheLocally);
-      break;
     }
 
     case kV8CacheOptionsDefault:
@@ -355,6 +390,8 @@ static CompileFn SelectCompileFunction(
                               CacheTag(kCacheTagCode, cache_handler))
                         : nullptr);
       if (code_cache) {
+        ReportCompileHeuristicsHistogram(
+            CompileHeuristicsDecision::kConsumeCodeCache);
         return WTF::Bind(CompileAndConsumeCache, WrapPersistent(cache_handler),
                          std::move(code_cache),
                          v8::ScriptCompiler::kConsumeCodeCache);
@@ -362,9 +399,13 @@ static CompileFn SelectCompileFunction(
       if (cache_options != kV8CacheOptionsAlways &&
           !IsResourceHotForCaching(cache_handler, kHotHours)) {
         V8ScriptRunner::SetCacheTimeStamp(cache_handler);
+        ReportCompileHeuristicsHistogram(
+            CompileHeuristicsDecision::kCacheTooCold);
         return WTF::Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable);
       }
       uint32_t code_cache_tag = CacheTag(kCacheTagCode, cache_handler);
+      ReportCompileHeuristicsHistogram(
+          CompileHeuristicsDecision::kProduceCodeCache);
       return WTF::Bind(CompileAndProduceCache, WrapPersistent(cache_handler),
                        code_cache_tag, v8::ScriptCompiler::kProduceCodeCache,
                        CachedMetadataHandler::kSendToPlatform);
@@ -394,6 +435,11 @@ CompileFn SelectCompileFunction(V8CacheOptions cache_options,
   DCHECK(!resource->ErrorOccurred());
   DCHECK(streamer->IsFinished());
   DCHECK(!streamer->StreamingSuppressed());
+
+  // Streaming compilation may involve use of code cache.
+  // TODO(kouhei): Consider adding further breakdown if needed.
+  ReportCompileHeuristicsHistogram(
+      CompileHeuristicsDecision::kStreamingCompile);
   return WTF::Bind(PostStreamCompile, cache_options,
                    WrapPersistent(resource->CacheHandler()),
                    WrapPersistent(streamer));

tools/metrics/histograms/enums.xml

@@ -5790,6 +5790,35 @@ uploading your change for review.  These are checked by presubmit scripts.
   <int value="2" label="Successful first layout"/>
 </enum>
 
+<enum name="CompileHeuristicsDecision">
+  <int value="0" label="NoCacheHandler">
+    No CachedMetadataHandler was provided, thus caching functionality is
+    disabled.
+  </int>
+  <int value="1" label="CachingDisabled">Caching is disabled by settings.</int>
+  <int value="2" label="CodeTooShortToCache">
+    The script is too short to benefit from caching, thus caching functionality
+    is disabled.
+  </int>
+  <int value="3" label="CacheTooCold">
+    The script is not loaded often enough to benefit from caching, thus not
+    producing cache.
+  </int>
+  <int value="4" label="ProduceParserCache">
+    Parser cache is produced for the script when compiled.
+  </int>
+  <int value="5" label="ConsumeParserCache">
+    Consume previously generated parser cache for the script.
+  </int>
+  <int value="6" label="ProduceCodeCache">
+    Code cache is produced for the script when compiled.
+  </int>
+  <int value="7" label="ConsumeCodeCache">
+    Consume previously generated code cache for the script.
+  </int>
+  <int value="8" label="StreamingCompile">Use streamed compilation result.</int>
+</enum>
+
 <enum name="ComponentUpdaterCalls">
   <int value="0" label="Install"/>
   <int value="1" label="Update"/>

tools/metrics/histograms/histograms.xml

@@ -88773,6 +88773,15 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
   <summary>Time spent in V8 compiler (full codegen) for eval.</summary>
 </histogram>
 
+<histogram name="V8.CompileHeuristicsDecision" enum="CompileHeuristicsDecision">
+  <owner>kouhei@chromium.org</owner>
+  <summary>
+    V8 script compile function variant which was picked. This contains
+    information such as {if,why} v8 {code,parser} was
+    {produced,consumed,bypassed}.
+  </summary>
+</histogram>
+
 <histogram name="V8.CompileInlineScriptMicroSeconds" units="microseconds">
   <owner>yangguo@chromium.org</owner>
   <summary>Time spent compiling an inline script.</summary>