Before rewriting metadata cache entries for on-the-fly fetches, do a

read to see if the new value is different.

This means we will do more cache reads but fewer cache writes most of
the time.

Skip optimization-locks for on-the-fly resources, which makes no sense
for cheap uncacheable optimizations.

Author: jmarantz

net/instaweb/rewriter/css_embedded_config_test.cc

@@ -102,7 +102,12 @@ class CssEmbeddedConfigTest : public CssRewriteTestBase {
     ResponseHeaders image_headers;
     GoogleString image;
     EXPECT_TRUE(FetchResourceUrl(image_url, &image, &image_headers));
-    EXPECT_EQ(1, lru_cache()->num_hits());
+    bool is_on_the_fly = image_url.find(".ce.") != StringPiece::npos;
+    if (is_on_the_fly) {
+      EXPECT_EQ(2, lru_cache()->num_hits());
+    } else {
+      EXPECT_EQ(1, lru_cache()->num_hits());
+    }
     EXPECT_EQ(0, lru_cache()->num_misses());
     return image;
   }

net/instaweb/rewriter/public/rewrite_context.h

@@ -611,7 +611,7 @@ class RewriteContext {
   virtual int64 GetRewriteDeadlineAlarmMs() const;
 
   // Should the context call LockForCreation before checking the cache?
-  virtual bool CreationLockBeforeStartFetch() const { return true; }
+  virtual bool CreationLockBeforeStartFetch() const;
 
   // Should the context fail to serve the rewritten resource if the hash
   // doesn't match user requested hash?
@@ -637,6 +637,7 @@ class RewriteContext {
   class DistributedRewriteCallback;
   class DistributedRewriteFetch;
   class OutputCacheCallback;
+  class WriteIfChanged;
   class LookupMetadataForOutputResourceCallback;
   class HTTPCacheCallback;
   class ResourceCallbackUtils;

net/instaweb/rewriter/rewrite_context.cc

@@ -571,6 +571,46 @@ class RewriteContext::OutputCacheCallback : public CacheInterface::Callback {
   scoped_ptr<CacheLookupResult> cache_result_;
 };
 
+// When serving on-the-fly resources, our system rewrites the metadata
+// cache entry on each request, which is necessary if during the
+// serving we've detected any expirations or cache mismatches.  To reduce
+// the number of cache-writes (which may write-through an L1 to a slower L2),
+// we first read the existing entry (possibly from L1) and compare it to what
+// we intend to write.
+//
+// This callback manages that flow.
+class RewriteContext::WriteIfChanged : public CacheInterface::Callback {
+ public:
+  // Reads value of key in cache, checking against *val.  If different,
+  // *val is put back into the cache.
+  //
+  // Note that *val will be cleared at the call-site (by swapping with an empty
+  // string) when this call is made.
+  static void ReadCheckAndWrite(const GoogleString& key, GoogleString* val,
+                                CacheInterface* cache) {
+    cache->Get(key, new WriteIfChanged(key, val, cache));
+  }
+
+  virtual void Done(CacheInterface::KeyState state) {
+    if ((state != CacheInterface::kAvailable) || (value()->Value() != value_)) {
+      cache_->PutSwappingString(key_, &value_);
+    }
+    delete this;
+  }
+
+ private:
+  WriteIfChanged(const GoogleString& key, GoogleString* value,
+                 CacheInterface* cache)
+      : key_(key),
+        cache_(cache) {
+    value_.swap(*value);
+  }
+
+  const GoogleString key_;
+  GoogleString value_;
+  CacheInterface* cache_;
+};
+
 // Like OutputCacheCallback but forwarding info to an external user rather
 // than to RewriteContext
 class RewriteContext::LookupMetadataForOutputResourceCallback
@@ -2162,7 +2202,16 @@ void RewriteContext::WritePartition() {
         StringOutputStream sstream(&buf);  // finalizes buf in destructor
         partitions_->SerializeToZeroCopyStream(&sstream);
       }
-      metadata_cache->PutSwappingString(partition_key_, &buf);
+
+      // Unchanged on-the-fly resources usually have their metadata
+      // rewritten needlessly on fetches, so in that case do a Read
+      // first and check whether the new bits are any different, as in
+      // most cases a read is cheaper than a write.
+      if (IsFetchRewrite() && (kind() == kOnTheFlyResource)) {
+        WriteIfChanged::ReadCheckAndWrite(partition_key_, &buf, metadata_cache);
+      } else {
+        metadata_cache->PutSwappingString(partition_key_, &buf);
+      }
     }
   } else {
     // TODO(jmarantz): if our rewrite failed due to lock contention or
@@ -3165,6 +3214,11 @@ int64 RewriteContext::GetRewriteDeadlineAlarmMs() const {
   return Driver()->rewrite_deadline_ms();
 }
 
+bool RewriteContext::CreationLockBeforeStartFetch() const {
+  // Don't take rewrite-locks for on-the-fly resources.
+  return (kind() != kOnTheFlyResource);
+}
+
 namespace {
 
 void AppendBool(GoogleString* out, const char* name, bool val,

net/instaweb/rewriter/rewrite_context_test.cc

@@ -986,8 +986,8 @@ TEST_F(RewriteContextTest, TrimFetchOnTheFly) {
                             "a.css", "css", &content));
   EXPECT_EQ("a", content);
   EXPECT_EQ(0, lru_cache()->num_hits());
-  EXPECT_EQ(1, lru_cache()->num_misses());   // 1 because output is not saved
-  EXPECT_EQ(2, lru_cache()->num_inserts());  // input, metadata
+  EXPECT_EQ(2, lru_cache()->num_misses());   // output + metadata.
+  EXPECT_EQ(2, lru_cache()->num_inserts());  // input + metadata.
   EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
   ClearStats();
   content.clear();
@@ -997,7 +997,7 @@ TEST_F(RewriteContextTest, TrimFetchOnTheFly) {
       kTestDomain, TrimWhitespaceRewriter::kFilterId, "a.css", "css",
       &content));
   EXPECT_EQ("a", content);
-  EXPECT_EQ(1, lru_cache()->num_hits());
+  EXPECT_EQ(2, lru_cache()->num_hits());
   EXPECT_EQ(0, lru_cache()->num_misses());
   EXPECT_EQ(0, lru_cache()->num_inserts());
   EXPECT_EQ(0, counting_url_async_fetcher()->fetch_count());
@@ -1303,7 +1303,7 @@ TEST_F(RewriteContextTest, FetchUncacheableWithRewritesInLineOfServing) {
                             &content));
   EXPECT_EQ("a", content);
   EXPECT_EQ(0, lru_cache()->num_hits());
-  EXPECT_EQ(1, lru_cache()->num_misses());
+  EXPECT_EQ(2, lru_cache()->num_misses());
   EXPECT_EQ(2, lru_cache()->num_inserts());  // name mapping & uncacheable memo
   EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
 
@@ -1318,7 +1318,7 @@ TEST_F(RewriteContextTest, FetchUncacheableWithRewritesInLineOfServing) {
                               "css",
                               &content));
     EXPECT_EQ("a", content);
-    EXPECT_EQ(1, lru_cache()->num_hits());
+    EXPECT_EQ(2, lru_cache()->num_hits());
     EXPECT_EQ(0, lru_cache()->num_misses());
     EXPECT_EQ(0, lru_cache()->num_inserts());
     EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
@@ -1348,7 +1348,7 @@ TEST_F(RewriteContextTest, FetchUncacheableWithRewritesInLineOfServing) {
                               "css",
                               &content));
     EXPECT_EQ("b", content);
-    EXPECT_EQ(1, lru_cache()->num_hits());
+    EXPECT_EQ(2, lru_cache()->num_hits());
     EXPECT_EQ(0, lru_cache()->num_misses());
     EXPECT_EQ(0, lru_cache()->num_inserts());
     EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
@@ -1364,7 +1364,7 @@ TEST_F(RewriteContextTest, FetchUncacheableWithRewritesInLineOfServing) {
                             "css",
                             &content));
   EXPECT_EQ("b", content);
-  EXPECT_EQ(1, lru_cache()->num_hits());
+  EXPECT_EQ(2, lru_cache()->num_hits());
   EXPECT_EQ(0, lru_cache()->num_misses());
   EXPECT_EQ(2, lru_cache()->num_inserts());
   EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
@@ -1669,7 +1669,7 @@ TEST_F(RewriteContextTest, CacheControlWithMultipleInputResources) {
   EXPECT_EQ(" a b a ", content);
 
   EXPECT_EQ(0, lru_cache()->num_hits());
-  EXPECT_EQ(3, lru_cache()->num_misses());   // 3 inputs.
+  EXPECT_EQ(4, lru_cache()->num_misses());   // 3 inputs.
   EXPECT_EQ(4, lru_cache()->num_inserts()) <<
       "partition, 2 inputs, 1 non-cacheability note";
   EXPECT_EQ(3, counting_url_async_fetcher()->fetch_count());
@@ -1771,7 +1771,7 @@ TEST_F(RewriteContextTest, CacheControlWithMultipleInputResourcesAndNoStore) {
   EXPECT_EQ(" a b a  a ", content);
 
   EXPECT_EQ(0, lru_cache()->num_hits());
-  EXPECT_EQ(4, lru_cache()->num_misses());   // 4 inputs.
+  EXPECT_EQ(5, lru_cache()->num_misses());   // 4 inputs + metadata.
   EXPECT_EQ(5, lru_cache()->num_inserts())
       << "partition, 2 inputs, 2 non-cacheability notes";
   EXPECT_EQ(4, counting_url_async_fetcher()->fetch_count());
@@ -2057,18 +2057,20 @@ TEST_F(RewriteContextTest, FetchColdCacheOnTheFlyNotFound) {
   EXPECT_FALSE(FetchResource(kTestDomain, TrimWhitespaceRewriter::kFilterId,
                              "a.css", "css", &content));
   EXPECT_EQ(0, lru_cache()->num_hits());
-  EXPECT_EQ(1, lru_cache()->num_misses());
+  EXPECT_EQ(2, lru_cache()->num_misses());
   EXPECT_EQ(2, lru_cache()->num_inserts());  // fetch failure, metadata.
+  EXPECT_EQ(0, lru_cache()->num_identical_reinserts());
   EXPECT_EQ(1, counting_url_async_fetcher()->fetch_count());
   ClearStats();
 
   // Try it again with a warm cache.  We'll get a 'hit' which will inform us
   // that this resource is not fetchable.
   EXPECT_FALSE(FetchResource(kTestDomain, TrimWhitespaceRewriter::kFilterId,
                              "a.css", "css", &content));
-  EXPECT_EQ(1, lru_cache()->num_hits());
+  EXPECT_EQ(2, lru_cache()->num_hits());
   EXPECT_EQ(0, lru_cache()->num_misses());
   EXPECT_EQ(0, lru_cache()->num_inserts());  // We "remember" the fetch failure
+  EXPECT_EQ(0, lru_cache()->num_identical_reinserts());
   EXPECT_EQ(0, counting_url_async_fetcher()->fetch_count());
 }
 

net/instaweb/rewriter/rewrite_driver_test.cc

@@ -702,10 +702,12 @@ TEST_F(RewriteDriverTest, TestCacheUseOnTheFly) {
   int cold_num_inserts = lru_cache()->num_inserts();
   EXPECT_EQ(2, cold_num_inserts);
 
-  // Warm load. This one re-inserts in the rname entry, without changing it.
+  // Warm load. This one does a read-check to avoid a re-inserts in the
+  // rname entry.
   EXPECT_TRUE(TryFetchResource(cache_extended_url));
   EXPECT_EQ(cold_num_inserts, lru_cache()->num_inserts());
-  EXPECT_EQ(1, lru_cache()->num_identical_reinserts());
+  EXPECT_EQ(2, lru_cache()->num_hits());
+  EXPECT_EQ(0, lru_cache()->num_identical_reinserts());
 }
 
 // Verifies that the computed rewrite delay agrees with expectations
@@ -766,10 +768,12 @@ TEST_F(RewriteDriverTest, TestCacheUseOnTheFlyWithInvalidation) {
   int cold_num_inserts = lru_cache()->num_inserts();
   EXPECT_EQ(2, cold_num_inserts);
 
-  // Warm load. This one re-inserts in the rname entry, without changing it.
+  // Warm load. This one does a read-check to avoid a re-inserts in the
+  // rname entry.
   EXPECT_TRUE(TryFetchResource(cache_extended_url));
   EXPECT_EQ(cold_num_inserts, lru_cache()->num_inserts());
-  EXPECT_EQ(1, lru_cache()->num_identical_reinserts());
+  EXPECT_EQ(0, lru_cache()->num_identical_reinserts());
+  EXPECT_EQ(2, lru_cache()->num_hits());
 
   // Set cache invalidation timestamp (to now, so that response date header is
   // in the "past") and load.

net/instaweb/rewriter/rewrite_test_base.cc

@@ -607,8 +607,13 @@ void RewriteTestBase::TestServeFiles(
   EXPECT_EQ(0U, lru_cache()->num_hits());
   EXPECT_TRUE(FetchResource(kTestDomain, filter_id,
                             rewritten_name, rewritten_ext, &content));
+  RewriteFilter* filter = rewrite_driver_->FindFilter(filter_id);
   if (lru_cache()->IsHealthy()) {
-    EXPECT_EQ(1U, lru_cache()->num_hits());
+    if (filter->ComputeOnTheFly()) {
+      EXPECT_EQ(2U, lru_cache()->num_hits());
+    } else {
+      EXPECT_EQ(1U, lru_cache()->num_hits());
+    }
   }
   EXPECT_STREQ(rewritten_content, content);
 
@@ -621,7 +626,6 @@ void RewriteTestBase::TestServeFiles(
   EXPECT_EQ(rewritten_content, content);
 
   // Now we expect the cache entry to be there.
-  RewriteFilter* filter = rewrite_driver_->FindFilter(filter_id);
   if (!filter->ComputeOnTheFly() && lru_cache()->IsHealthy()) {
     HTTPValue value;
     ResponseHeaders response_headers;

pagespeed/automatic/proxy_interface_test.cc

@@ -2476,7 +2476,7 @@ TEST_F(ProxyInterfaceTest, UncacheableResourcesNotCachedOnResourceFetch) {
   EXPECT_EQ("a", out_text);
   EXPECT_EQ(1, lru_cache()->num_hits());  // input uncacheable memo
   EXPECT_EQ(0, http_cache()->cache_hits()->Get());
-  EXPECT_EQ(0, lru_cache()->num_misses());
+  EXPECT_EQ(1, lru_cache()->num_misses());
   EXPECT_EQ(1, http_cache()->cache_misses()->Get());  // input uncacheable memo
   EXPECT_EQ(1, lru_cache()->num_inserts());  // mapping
   EXPECT_EQ(1, lru_cache()->num_identical_reinserts());  // uncacheable memo
@@ -2492,13 +2492,12 @@ TEST_F(ProxyInterfaceTest, UncacheableResourcesNotCachedOnResourceFetch) {
                  false  /* proxy_fetch_property_callback_collector_created */);
   EXPECT_TRUE(out_headers.HasValue(HttpAttributes::kCacheControl, "private"));
   EXPECT_EQ("a", out_text);
-  EXPECT_EQ(1, lru_cache()->num_hits());  // uncacheable memo
+  EXPECT_EQ(2, lru_cache()->num_hits());  // uncacheable memo & modified check
   EXPECT_EQ(0, http_cache()->cache_hits()->Get());
   EXPECT_EQ(0, lru_cache()->num_misses());
   EXPECT_EQ(1, http_cache()->cache_misses()->Get());  // uncacheable memo
   EXPECT_EQ(0, lru_cache()->num_inserts());
-  EXPECT_EQ(2, lru_cache()->num_identical_reinserts())
-      << "uncacheable memo, metadata";
+  EXPECT_EQ(1, lru_cache()->num_identical_reinserts()) << "uncacheable memo";
   EXPECT_EQ(1, http_cache()->cache_inserts()->Get());  // uncacheable memo
 
   // Since the original response is not cached, we should pick up changes in the
@@ -2514,14 +2513,13 @@ TEST_F(ProxyInterfaceTest, UncacheableResourcesNotCachedOnResourceFetch) {
                  false  /* proxy_fetch_property_callback_collector_created */);
   EXPECT_TRUE(out_headers.HasValue(HttpAttributes::kCacheControl, "private"));
   EXPECT_EQ("b", out_text);
-  EXPECT_EQ(1, lru_cache()->num_hits());  // uncacheable memo
+  EXPECT_EQ(2, lru_cache()->num_hits());  // uncacheable memo & modified-check
   EXPECT_EQ(0, http_cache()->cache_hits()->Get());
   EXPECT_EQ(0, lru_cache()->num_misses());
-  EXPECT_EQ(1, http_cache()->cache_misses()->Get());  // uncacheable memo
+  EXPECT_EQ(1, http_cache()->cache_misses()->Get()) << "uncacheable memo";
   EXPECT_EQ(0, lru_cache()->num_inserts());
-  EXPECT_EQ(2, lru_cache()->num_identical_reinserts())
-      << "uncacheable memo, metadata";
-  EXPECT_EQ(1, http_cache()->cache_inserts()->Get());  // uncacheable memo
+  EXPECT_EQ(1, lru_cache()->num_identical_reinserts()) << "uncacheable memo";
+  EXPECT_EQ(1, http_cache()->cache_inserts()->Get()) << "uncacheable memo";
 }
 
 // No matter what options->respect_vary() is set to we will respect HTML Vary