Add experimental v8 code cache options.

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 20 matching lines @@
 #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 "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 {
@@ skipping 98 matching lines @@
 {
     return resource->cachedMetadata(tag)
         ? compileAndConsumeCache(resource, tag, consumeOptions, compressed, isolate, code, origin)
         : compileAndProduceCache(resource, tag, produceOptions, compressed, cacheType, isolate, code, origin);
 }
 
 enum CacheTagKind {
     CacheTagParser = 0,
     CacheTagCode = 1,
     CacheTagCodeCompressed = 2,
-
+    CacheTagTimeStamp = 3,
     CacheTagLast
 };
 
 static const int kCacheTagKindSize = 2;
 
 unsigned cacheTag(CacheTagKind kind, Resource* resource)
 {
     static_assert((1 << kCacheTagKindSize) >= CacheTagLast, "CacheTagLast must be large enough");
 
     static unsigned v8CacheDataVersion = v8::ScriptCompiler::CachedDataVersionTag() << kCacheTagKindSize;
 
     // A script can be (successfully) interpreted with different encodings,
     // 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();
+    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;
+}
+
 // 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)
 {
     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) {
@@ skipping 60 matching lines @@
         // Always use code caching.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagCode, resource), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, false, Resource::SendToPlatform);
         break;
 
     case V8CacheOptionsCodeCompressed:
         // Always use code caching. Compress depending on cacheOptions.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagCodeCompressed, resource), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, true, Resource::SendToPlatform);
         break;
 
     case V8CacheOptionsHeuristics:
-    case V8CacheOptionsHeuristicsMobile: {
+    case V8CacheOptionsHeuristicsMobile:
+    case V8CacheOptionsHeuristicsDefault:
+    case V8CacheOptionsHeuristicsDefaultMobile: {
         // We expect compression to win on mobile devices, due to relatively
         // slow storage.
         bool compress = cacheOptions == V8CacheOptionsHeuristicsMobile;
         CacheTagKind codeTag = compress ? CacheTagCodeCompressed : CacheTagCode;
 
         // Either code or parser caching, depending on code size and what we
         // already have in the cache.
         unsigned codeCacheTag = cacheTag(codeTag, resource);
         if (resource->cachedMetadata(codeCacheTag))
             return bind(compileAndConsumeCache, resource, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, compress);
         if (code->Length() < mediumCodeLength)
             return bind(compileAndProduceCache, resource, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, compress, Resource::SendToPlatform);
-        unsigned parserCacheTag = cacheTag(CacheTagParser, resource);
-        if (resource->cachedMetadata(parserCacheTag))
-            return bind(compileAndConsumeCache, resource, parserCacheTag, v8::ScriptCompiler::kConsumeParserCache, false);
-        return bind(compileAndProduceCache, resource, parserCacheTag, v8::ScriptCompiler::kProduceParserCache, false, Resource::SendToPlatform);
+        Resource::MetadataCacheType cacheType = Resource::CacheLocally;
+        if (cacheOptions == V8CacheOptionsHeuristics || cacheOptions == V8CacheOptionsHeuristicsMobile)
+            cacheType = Resource::SendToPlatform;
+        return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, cacheType);
         break;
     }
 
+    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)) {

[marja, 2015/01/20 13:14:32]

So this caches the code if we have recently compiled it, right? So it first
compiles w/o caching, then compiles again, and if the first compilation was
recent enough, it now puts data to the cache.

+            setCacheTimeStamp(resource);
+            return bind(compileWithoutOptions);
+        }
+        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);
         break;
     }
 
     // All switch branches should return and we should never get here.
     // But some compilers aren't sure, hence this default.
@@ skipping 168 matching lines @@
 {
     return cacheTag(CacheTagParser, resource);
 }
 
 unsigned V8ScriptRunner::tagForCodeCache(Resource* resource)
 {
     return cacheTag(CacheTagCode, resource);
 }
 
 } // namespace blink