- Fixed the compilation cache so Put works....

src/compilation-cache.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "compilation-cache.h"
 
 namespace v8 {
 namespace internal {
 
-
 // The number of sub caches covering the different types to cache.
 static const int kSubCacheCount = 4;
 
 // The number of generations for each sub cache.
 // The number of ScriptGenerations is carefully chosen based on histograms.
 // See issue 458: http://code.google.com/p/v8/issues/detail?id=458
 static const int kScriptGenerations = 5;
 static const int kEvalGlobalGenerations = 2;
 static const int kEvalContextualGenerations = 2;
 static const int kRegExpGenerations = 2;
 
 // Initial size of each compilation cache table allocated.
 static const int kInitialCacheSize = 64;
 
+// Index for the first generation in the cache.
+static const int kFirstGeneration = 0;
+
 // The compilation cache consists of several generational sub-caches which uses
 // this class as a base class. A sub-cache contains a compilation cache tables
 // for each generation of the sub-cache. Since the same source code string has
 // different compiled code for scripts and evals, we use separate sub-caches
 // for different compilation modes, to avoid retrieving the wrong result.
 class CompilationSubCache {
  public:
   explicit CompilationSubCache(int generations): generations_(generations) {
     tables_ = NewArray<Object*>(generations);
   }
 
   ~CompilationSubCache() { DeleteArray(tables_); }
 
   // Get the compilation cache tables for a specific generation.
   Handle<CompilationCacheTable> GetTable(int generation);
 
+  // Accessors for first generation.
+  Handle<CompilationCacheTable> GetFirstTable() {
+    return GetTable(kFirstGeneration);
+  }
+  void SetFirstTable(Handle<CompilationCacheTable> value) {
+    ASSERT(kFirstGeneration < generations_);
+    tables_[kFirstGeneration] = *value;
+  }
+
   // Age the sub-cache by evicting the oldest generation and creating a new
   // young generation.
   void Age();
 
   // GC support.
   void Iterate(ObjectVisitor* v);
 
   // Clear this sub-cache evicting all its content.
   void Clear();
 
@@ skipping 14 matching lines @@
   explicit CompilationCacheScript(int generations)
       : CompilationSubCache(generations) { }
 
   Handle<JSFunction> Lookup(Handle<String> source,
                             Handle<Object> name,
                             int line_offset,
                             int column_offset);
   void Put(Handle<String> source, Handle<JSFunction> boilerplate);
 
  private:
+  // Note: Returns a new hash table if operation results in expansion.
+  Handle<CompilationCacheTable> TablePut(Handle<String> source,
+                                         Handle<JSFunction> boilerplate);
+
   bool HasOrigin(Handle<JSFunction> boilerplate,
                  Handle<Object> name,
                  int line_offset,
                  int column_offset);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheScript);
 };
 
 
 // Sub-cache for eval scripts.
 class CompilationCacheEval: public CompilationSubCache {
  public:
   explicit CompilationCacheEval(int generations)
       : CompilationSubCache(generations) { }
 
   Handle<JSFunction> Lookup(Handle<String> source, Handle<Context> context);
 
   void Put(Handle<String> source,
            Handle<Context> context,
            Handle<JSFunction> boilerplate);
 
+ private:
+  // Note: Returns a new hash table if operation results in expansion.
+  Handle<CompilationCacheTable> TablePut(Handle<String> source,
+                                         Handle<Context> context,
+                                         Handle<JSFunction> boilerplate);
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheEval);
 };
 
 
 // Sub-cache for regular expressions.
 class CompilationCacheRegExp: public CompilationSubCache {
  public:
   explicit CompilationCacheRegExp(int generations)
       : CompilationSubCache(generations) { }
 
   Handle<FixedArray> Lookup(Handle<String> source, JSRegExp::Flags flags);
 
   void Put(Handle<String> source,
            JSRegExp::Flags flags,
            Handle<FixedArray> data);
+ private:
+  // Note: Returns a new hash table if operation results in expansion.
+  Handle<CompilationCacheTable> TablePut(Handle<String> source,
+                                         JSRegExp::Flags flags,
+                                         Handle<FixedArray> data);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheRegExp);
 };
 
 
 // Statically allocate all the sub-caches.
 static CompilationCacheScript script(kScriptGenerations);
 static CompilationCacheEval eval_global(kEvalGlobalGenerations);
 static CompilationCacheEval eval_contextual(kEvalContextualGenerations);
 static CompilationCacheRegExp reg_exp(kRegExpGenerations);
@@ skipping 127 matching lines @@
     if (generation != 0) Put(source, boilerplate);
     Counters::compilation_cache_hits.Increment();
     return boilerplate;
   } else {
     Counters::compilation_cache_misses.Increment();
     return Handle<JSFunction>::null();
   }
 }
 
 
+Handle<CompilationCacheTable> CompilationCacheScript::TablePut(
+    Handle<String> source,
+    Handle<JSFunction> boilerplate) {
+  CALL_HEAP_FUNCTION(GetFirstTable()->Put(*source, *boilerplate),
+                     CompilationCacheTable);
+}
+
+
 void CompilationCacheScript::Put(Handle<String> source,
                                  Handle<JSFunction> boilerplate) {
   HandleScope scope;
   ASSERT(boilerplate->IsBoilerplate());
-  Handle<CompilationCacheTable> table = GetTable(0);
-  CALL_HEAP_FUNCTION_VOID(table->Put(*source, *boilerplate));
+  SetFirstTable(TablePut(source, boilerplate));
 }
 
 
 Handle<JSFunction> CompilationCacheEval::Lookup(Handle<String> source,
                                                 Handle<Context> context) {
   // Make sure not to leak the table into the surrounding handle
   // scope. Otherwise, we risk keeping old tables around even after
   // having cleared the cache.
   Object* result = NULL;
   int generation;
@@ skipping 13 matching lines @@
     }
     Counters::compilation_cache_hits.Increment();
     return boilerplate;
   } else {
     Counters::compilation_cache_misses.Increment();
     return Handle<JSFunction>::null();
   }
 }
 
 
+Handle<CompilationCacheTable> CompilationCacheEval::TablePut(
+    Handle<String> source,
+    Handle<Context> context,
+    Handle<JSFunction> boilerplate) {
+  CALL_HEAP_FUNCTION(GetFirstTable()->PutEval(*source, *context, *boilerplate),
+                     CompilationCacheTable);
+}
+
+
 void CompilationCacheEval::Put(Handle<String> source,
                                Handle<Context> context,
                                Handle<JSFunction> boilerplate) {
   HandleScope scope;
   ASSERT(boilerplate->IsBoilerplate());
-  Handle<CompilationCacheTable> table = GetTable(0);
-  CALL_HEAP_FUNCTION_VOID(table->PutEval(*source, *context, *boilerplate));
+  SetFirstTable(TablePut(source, context, boilerplate));
 }
 
 
 Handle<FixedArray> CompilationCacheRegExp::Lookup(Handle<String> source,
                                                   JSRegExp::Flags flags) {
   // Make sure not to leak the table into the surrounding handle
   // scope. Otherwise, we risk keeping old tables around even after
   // having cleared the cache.
   Object* result = NULL;
   int generation;
@@ skipping 13 matching lines @@
     }
     Counters::compilation_cache_hits.Increment();
     return data;
   } else {
     Counters::compilation_cache_misses.Increment();
     return Handle<FixedArray>::null();
   }
 }
 
 
+Handle<CompilationCacheTable> CompilationCacheRegExp::TablePut(
+    Handle<String> source,
+    JSRegExp::Flags flags,
+    Handle<FixedArray> data) {
+  CALL_HEAP_FUNCTION(GetFirstTable()->PutRegExp(*source, flags, *data),
+                     CompilationCacheTable);
+}
+
+
 void CompilationCacheRegExp::Put(Handle<String> source,
                                  JSRegExp::Flags flags,
                                  Handle<FixedArray> data) {
   HandleScope scope;
-  Handle<CompilationCacheTable> table = GetTable(0);
-  CALL_HEAP_FUNCTION_VOID(table->PutRegExp(*source, flags, *data));
+  SetFirstTable(TablePut(source, flags, data));
 }
 
 
 Handle<JSFunction> CompilationCache::LookupScript(Handle<String> source,
                                                   Handle<Object> name,
                                                   int line_offset,
                                                   int column_offset) {
   if (!IsEnabled()) {
     return Handle<JSFunction>::null();
   }
@@ skipping 96 matching lines @@
 }
 
 
 void CompilationCache::Disable() {
   enabled = false;
   Clear();
 }
 
 
 } }  // namespace v8::internal