Add histograms for cacheable and noncacheable compilation times.

Source/bindings/core/v8/V8ScriptRunner.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 19 matching lines @@
 #include "bindings/core/v8/ScriptStreamer.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8RecursionScope.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/CachedMetadata.h"
 #include "core/fetch/ScriptResource.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
+#include "public/platform/Platform.h"
 #include "third_party/snappy/src/snappy.h"
 #include "wtf/CurrentTime.h"
 
 #if defined(WTF_OS_WIN)
 #include <malloc.h>
 #else
 #include <alloca.h>
 #endif
 
 namespace blink {
 
 namespace {
 
 const int kMaxRecursionDepth = 22;
 
+class V8CompileHistogram {
+public:
+    enum Cacheability { Cacheable, Noncacheable };
+    explicit V8CompileHistogram(Cacheability);
+    ~V8CompileHistogram();
+
+private:
+    Cacheability m_cacheability;
+    double m_timeStamp;
+};
+
+V8CompileHistogram::V8CompileHistogram(V8CompileHistogram::Cacheability cacheability)
+    : m_cacheability(cacheability)
+    , m_timeStamp(WTF::currentTime())
+{
+}
+
+V8CompileHistogram::~V8CompileHistogram()
+{
+    int64_t elapsedMicroSeconds = static_cast<int64_t>((WTF::currentTime() - m_timeStamp) * 1000000);
+    const char* name = (m_cacheability == Cacheable) ? "V8.CompileCacheableMicroSeconds" : "V8.CompileNoncacheableMicroSeconds";
+    blink::Platform::current()->histogramCustomCounts(name, elapsedMicroSeconds, 0, 1000000, 50);
+}
+
 // In order to make sure all pending messages to be processed in
 // v8::Function::Call, we don't call handleMaxRecursionDepthExceeded
 // directly. Instead, we create a v8::Function of
 // throwStackOverflowException and call it.
 void throwStackOverflowException(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     V8ThrowException::throwRangeError(info.GetIsolate(), "Maximum call stack size exceeded.");
 }
 
 v8::Local<v8::Value> throwStackOverflowExceptionIfNeeded(v8::Isolate* isolate)
 {
     if (V8PerIsolateData::from(isolate)->isHandlingRecursionLevelError()) {
         // If we are already handling a recursion level error, we should
         // not invoke v8::Function::Call.
         return v8::Undefined(isolate);
     }
     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(true);
     v8::Local<v8::Value> result = v8::Function::New(isolate, throwStackOverflowException)->Call(v8::Undefined(isolate), 0, 0);
     V8PerIsolateData::from(isolate)->setIsHandlingRecursionLevelError(false);
     return result;
 }
 
 // Compile a script without any caching or compile options.
-v8::Local<v8::Script> compileWithoutOptions(v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
+v8::Local<v8::Script> compileWithoutOptions(V8CompileHistogram::Cacheability cacheability, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
+    V8CompileHistogram histogramScope(cacheability);
     v8::ScriptCompiler::Source source(code, origin);
     return v8::ScriptCompiler::Compile(isolate, &source, v8::ScriptCompiler::kNoCompileOptions);
 }
 
 // Compile a script, and consume a V8 cache that was generated previously.
 v8::Local<v8::Script> compileAndConsumeCache(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
+    V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
     CachedMetadata* cachedMetadata = resource->cachedMetadata(tag);
     const char* data = cachedMetadata->data();
     int length = cachedMetadata->size();
     std::string uncompressedOutput;
     bool invalidCache = false;
     if (compressed) {
         if (snappy::Uncompress(data, length, &uncompressedOutput)) {
             data = uncompressedOutput.data();
             length = uncompressedOutput.length();
         } else {
             invalidCache = true;
         }
     }
     v8::Local<v8::Script> script;
     if (invalidCache) {
-        script = compileWithoutOptions(isolate, code, origin);
+        v8::ScriptCompiler::Source source(code, origin);
+        script = v8::ScriptCompiler::Compile(isolate, &source, v8::ScriptCompiler::kNoCompileOptions);
     } else {
         v8::ScriptCompiler::CachedData* cachedData = new v8::ScriptCompiler::CachedData(
             reinterpret_cast<const uint8_t*>(data), length, v8::ScriptCompiler::CachedData::BufferNotOwned);
         v8::ScriptCompiler::Source source(code, origin, cachedData);
         script = v8::ScriptCompiler::Compile(isolate, &source, compileOptions);
         invalidCache = cachedData->rejected;
     }
     if (invalidCache)
         resource->clearCachedMetadata();
     return script;
 }
 
 // Compile a script, and produce a V8 cache for future use.
 v8::Local<v8::Script> compileAndProduceCache(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions compileOptions, bool compressed, Resource::MetadataCacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
+    V8CompileHistogram histogramScope(V8CompileHistogram::Cacheable);
     v8::ScriptCompiler::Source source(code, origin);
     v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, &source, compileOptions);
     const v8::ScriptCompiler::CachedData* cachedData = source.GetCachedData();
     if (cachedData) {
         const char* data = reinterpret_cast<const char*>(cachedData->data);
         int length = cachedData->length;
         std::string compressedOutput;
         if (compressed) {
             snappy::Compress(data, length, &compressedOutput);
             data = compressedOutput.data();
@@ skipping 34 matching lines @@
     // depending on the page it appears in. The cache doesn't know anything
     // about encodings, but the cached data is specific to one encoding. If we
     // later load the script from the cache and interpret it with a different
     // encoding, the cached data is not valid for that encoding.
     return (v8CacheDataVersion | kind) + StringHash::hash(resource->encoding());
 }
 
 // Store a timestamp to the cache as hint.
 void setCacheTimeStamp(ScriptResource* resource)
 {
-    double now = currentTime();
+    double now = WTF::currentTime();
     unsigned tag = cacheTag(CacheTagTimeStamp, resource);
     resource->setCachedMetadata(tag, reinterpret_cast<char*>(&now), sizeof(now), Resource::SendToPlatform);
 }
 
 // Check previously stored timestamp.
 bool isResourceHotForCaching(ScriptResource* resource)
 {
     const double kCacheWithinSeconds = 36 * 60 * 60;
     unsigned tag = cacheTag(CacheTagTimeStamp, resource);
     CachedMetadata* cachedMetadata = resource->cachedMetadata(tag);
     if (!cachedMetadata)
         return false;
     double timeStamp;
     const int size = sizeof(timeStamp);
     ASSERT(cachedMetadata->size() == size);
     memcpy(&timeStamp, cachedMetadata->data(), size);
-    return (currentTime() - timeStamp) < kCacheWithinSeconds;
+    return (WTF::currentTime() - timeStamp) < kCacheWithinSeconds;
 }
 
 // Final compile call for a streamed compilation. Most decisions have already
 // been made, but we need to write back data into the cache.
 v8::Local<v8::Script> postStreamCompile(ScriptResource* resource, ScriptStreamer* streamer, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
+    V8CompileHistogram histogramScope(V8CompileHistogram::Noncacheable);
     v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(isolate, streamer->source(), code, origin);
 
     // Whether to produce the cached data or not is decided when the
     // streamer is started. Here we only need to get the data out.
     const v8::ScriptCompiler::CachedData* newCachedData = streamer->source()->GetCachedData();
     if (newCachedData) {
         resource->clearCachedMetadata();
         v8::ScriptCompiler::CompileOptions options = streamer->compileOptions();
         switch (options) {
         case v8::ScriptCompiler::kProduceParserCache:
@@ skipping 26 matching lines @@
 
 // Select a compile function from any of the above, mainly depending on
 // cacheOptions.
 PassOwnPtr<CompileFn> selectCompileFunction(V8CacheOptions cacheOptions, ScriptResource* resource, v8::Handle<v8::String> code)
 {
     static const int minimalCodeLength = 1024;
     static const int mediumCodeLength = 300000;
 
     if (cacheOptions == V8CacheOptionsNone
         || !resource
-        || !resource->url().protocolIsInHTTPFamily()
-        || code->Length() < minimalCodeLength) {
-        // Never generate or use the cache in these circumstances.
-        return bind(compileWithoutOptions);
+        || !resource->url().protocolIsInHTTPFamily()) {
+        // Caching is not available in this case.
+        return bind(compileWithoutOptions, V8CompileHistogram::Noncacheable);
+    }
+
+    if (code->Length() < minimalCodeLength) {
+        // Do not cache for small scripts, though caching is available.
+        return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
     }
 
     // The cacheOptions will guide our strategy:
     switch (cacheOptions) {
     case V8CacheOptionsDefault:
     case V8CacheOptionsParseMemory:
         // Use parser-cache; in-memory only.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::CacheLocally);
         break;
 
@@ skipping 38 matching lines @@
     case V8CacheOptionsRecent:
     case V8CacheOptionsRecentSmall: {
         if (cacheOptions == V8CacheOptionsRecentSmall && code->Length() >= mediumCodeLength)
             return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::CacheLocally);
         unsigned codeCacheTag = cacheTag(CacheTagCode, resource);
         CachedMetadata* codeCache = resource->cachedMetadata(codeCacheTag);
         if (codeCache)
             return bind(compileAndConsumeCache, resource, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, false);
         if (!isResourceHotForCaching(resource)) {
             setCacheTimeStamp(resource);
-            return bind(compileWithoutOptions);
+            return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
         return bind(compileAndProduceCache, resource, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, false, Resource::SendToPlatform);
         break;
     }
 
     case V8CacheOptionsNone:
         // Shouldn't happen, as this is handled above.
         // Case is here so that compiler can check all cases are handles.
         ASSERT_NOT_REACHED();
-        return bind(compileWithoutOptions);
+        return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         break;
     }
 
     // All switch branches should return and we should never get here.
     // But some compilers aren't sure, hence this default.
     ASSERT_NOT_REACHED();
-    return bind(compileWithoutOptions);
+    return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
 }
 
 // Select a compile function for a streaming compile.
 PassOwnPtr<CompileFn> selectCompileFunction(ScriptResource* resource, ScriptStreamer* streamer)
 {
     // We don't stream scripts which don't have a Resource.
     ASSERT(resource);
     // Failed resources should never get this far.
     ASSERT(!resource->errorOccurred());
     ASSERT(streamer->isFinished());
@@ skipping 156 matching lines @@
 {
     return cacheTag(CacheTagParser, resource);
 }
 
 unsigned V8ScriptRunner::tagForCodeCache(Resource* resource)
 {
     return cacheTag(CacheTagCode, resource);
 }
 
 } // namespace blink