Tweak and repurpose code caching 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 138 matching lines @@
     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();
             length = compressedOutput.length();
         }
+        if (length > 1024) {
+            // Omit histogram samples for small cache data to avoid outliers.
+            int cacheSizeRatio = static_cast<int>(100.0 * length / code->Length());
+            blink::Platform::current()->histogramCustomCounts("V8.CodeCacheSizeRatio", cacheSizeRatio, 0, 10000, 50);
+        }
         resource->clearCachedMetadata();
         resource->setCachedMetadata(tag, data, length, cacheType);
     }
     return script;
 }
 
 // Compile a script, and consume or produce a V8 Cache, depending on whether the
 // given resource already has cached data available.
 v8::Local<v8::Script> compileAndConsumeOrProduce(ScriptResource* resource, unsigned tag, v8::ScriptCompiler::CompileOptions consumeOptions, v8::ScriptCompiler::CompileOptions produceOptions, bool compressed, Resource::MetadataCacheType cacheType, v8::Isolate* isolate, v8::Handle<v8::String> code, v8::ScriptOrigin origin)
 {
@@ skipping 28 matching lines @@
 
 // Store a timestamp to the cache as hint.
 void setCacheTimeStamp(ScriptResource* resource)
 {
     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)
+bool isResourceHotForCaching(ScriptResource* resource, int hotHours)
 {
-    const double kCacheWithinSeconds = 36 * 60 * 60;
+    const double kCacheWithinSeconds = hotHours * 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 (WTF::currentTime() - timeStamp) < kCacheWithinSeconds;
 }
@@ skipping 38 matching lines @@
 PassOwnPtr<CompileFn> bind(const A&... args)
 {
     return WTF::bind<v8::Isolate*, v8::Handle<v8::String>, v8::ScriptOrigin>(args...);
 }
 
 // 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()) {
+    if (!resource || !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.
+    if (cacheOptions == V8CacheOptionsNone)
         return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
-    }
 
     // The cacheOptions will guide our strategy:
+    // FIXME: Clean up code caching options. crbug.com/455187.
     switch (cacheOptions) {
     case V8CacheOptionsDefault:
     case V8CacheOptionsParseMemory:
+        if (code->Length() < minimalCodeLength) {
+            // Do not cache for small scripts, though caching is available.
+            return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
+        }
         // Use parser-cache; in-memory only.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::CacheLocally);
         break;
 
     case V8CacheOptionsParse:
         // Use parser-cache.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagParser, resource), v8::ScriptCompiler::kConsumeParserCache, v8::ScriptCompiler::kProduceParserCache, false, Resource::SendToPlatform);
         break;
 
+    case V8CacheOptionsHeuristicsDefault:
     case V8CacheOptionsCode:
         // Always use code caching.
         return bind(compileAndConsumeOrProduce, resource, cacheTag(CacheTagCode, resource), v8::ScriptCompiler::kConsumeCodeCache, v8::ScriptCompiler::kProduceCodeCache, false, Resource::SendToPlatform);
         break;
 
+    case V8CacheOptionsHeuristicsDefaultMobile:
     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 V8CacheOptionsHeuristicsDefault:
-    case V8CacheOptionsHeuristicsDefaultMobile: {
-        // We expect compression to win on mobile devices, due to relatively
-        // slow storage.
-        bool compress = (cacheOptions == V8CacheOptionsHeuristicsMobile || cacheOptions == V8CacheOptionsHeuristicsDefaultMobile);
-        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);
-        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);
+        bool compress = (cacheOptions == V8CacheOptionsRecentSmall || cacheOptions == V8CacheOptionsHeuristicsMobile);
+        unsigned codeCacheTag = cacheTag(compress ? CacheTagCodeCompressed : CacheTagCode, resource);
         CachedMetadata* codeCache = resource->cachedMetadata(codeCacheTag);
         if (codeCache)
-            return bind(compileAndConsumeCache, resource, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, false);
-        if (!isResourceHotForCaching(resource)) {
+            return bind(compileAndConsumeCache, resource, codeCacheTag, v8::ScriptCompiler::kConsumeCodeCache, compress);
+        int hotHours = (cacheOptions == V8CacheOptionsRecent || cacheOptions == V8CacheOptionsRecentSmall) ? 36 : 72;
+        if (!isResourceHotForCaching(resource, hotHours)) {
             setCacheTimeStamp(resource);
             return bind(compileWithoutOptions, V8CompileHistogram::Cacheable);
         }
-        return bind(compileAndProduceCache, resource, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, false, Resource::SendToPlatform);
+        return bind(compileAndProduceCache, resource, codeCacheTag, v8::ScriptCompiler::kProduceCodeCache, compress, 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.
+        // Case is here so that compiler can check all cases are handled.
         ASSERT_NOT_REACHED();
-        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, V8CompileHistogram::Cacheable);
 }
 
 // Select a compile function for a streaming compile.
@@ skipping 161 matching lines @@
 {
     return cacheTag(CacheTagParser, resource);
 }
 
 unsigned V8ScriptRunner::tagForCodeCache(Resource* resource)
 {
     return cacheTag(CacheTagCode, resource);
 }
 
 } // namespace blink