Generalized the EvalCache into a CompilationCache and enabled...

src/compiler.cc

 // Copyright 2006-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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (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 "bootstrapper.h"
 #include "codegen-inl.h"
+#include "compilation-cache.h"
 #include "compiler.h"
 #include "debug.h"
 #include "scopes.h"
 #include "rewriter.h"
 #include "usage-analyzer.h"
 
 namespace v8 { namespace internal {
 
 DEFINE_bool(strict, false, "strict error checking");
 DEFINE_int(min_preparse_length, 1024,
@@ skipping 121 matching lines @@
                                      Handle<Object> script_name,
                                      int line_offset, int column_offset,
                                      v8::Extension* extension,
                                      ScriptDataImpl* input_pre_data) {
   Counters::total_load_size.Increment(source->length());
   Counters::total_compile_size.Increment(source->length());
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
 
-  ScriptDataImpl* pre_data = input_pre_data;
-  if (pre_data == NULL && source->length() >= FLAG_min_preparse_length) {
-    Access<SafeStringInputBuffer> buf(&safe_string_input_buffer);
-    buf->Reset(source.location());
-    pre_data = PreParse(buf.value(), extension);
+  // Do a lookup in the compilation cache but not for extensions.
+  Handle<JSFunction> result;
+  if (extension == NULL) {
+    result = CompilationCache::LookupScript(source,
+                                            script_name,
+                                            line_offset,
+                                            column_offset);
   }
 
-  // Create a script object describing the script to be compiled.
-  Handle<Script> script = Factory::NewScript(source);
-  if (!script_name.is_null()) {
-    script->set_name(*script_name);
-    script->set_line_offset(Smi::FromInt(line_offset));
-    script->set_column_offset(Smi::FromInt(column_offset));
+  if (result.is_null()) {
+    // No cache entry found. Do pre-parsing and compile the script.
+    ScriptDataImpl* pre_data = input_pre_data;
+    if (pre_data == NULL && source->length() >= FLAG_min_preparse_length) {
+      Access<SafeStringInputBuffer> buf(&safe_string_input_buffer);
+      buf->Reset(source.location());
+      pre_data = PreParse(buf.value(), extension);
+    }
+
+    // Create a script object describing the script to be compiled.
+    Handle<Script> script = Factory::NewScript(source);
+    if (!script_name.is_null()) {
+      script->set_name(*script_name);
+      script->set_line_offset(Smi::FromInt(line_offset));
+      script->set_column_offset(Smi::FromInt(column_offset));
+    }
+
+    // Compile the function and add it to the cache.
+    result = MakeFunction(true, false, script, extension, pre_data);
+    if (extension == NULL && !result.is_null()) {
+      CompilationCache::Associate(source, CompilationCache::SCRIPT, result);
+    }
+
+    // Get rid of the pre-parsing data (if necessary).
+    if (input_pre_data == NULL && pre_data != NULL) {
+      delete pre_data;
+    }
   }
 
-  Handle<JSFunction> result =
-      MakeFunction(true, false, script, extension, pre_data);
-
-  if (input_pre_data == NULL && pre_data != NULL)
-    delete pre_data;
-
   return result;
 }
 
 
 Handle<JSFunction> Compiler::CompileEval(bool is_global,
                                          Handle<String> source) {
   Counters::total_eval_size.Increment(source->length());
   Counters::total_compile_size.Increment(source->length());
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
+  CompilationCache::Entry entry = is_global
+      ? CompilationCache::EVAL_GLOBAL
+      : CompilationCache::EVAL_CONTEXTUAL;
 
-  // Create a script object describing the script to be compiled.
-  Handle<Script> script = Factory::NewScript(source);
-  return MakeFunction(is_global, true, script, NULL, NULL);
+  // Do a lookup in the compilation cache; if the entry is not there,
+  // invoke the compiler and add the result to the cache.
+  Handle<JSFunction> result = CompilationCache::LookupEval(source, entry);
+  if (result.is_null()) {
+    // Create a script object describing the script to be compiled.
+    Handle<Script> script = Factory::NewScript(source);
+    result = MakeFunction(is_global, true, script, NULL, NULL);
+    if (!result.is_null()) {
+      CompilationCache::Associate(source, entry, result);
+    }
+  }
+  return result;
 }
 
 
 bool Compiler::CompileLazy(Handle<SharedFunctionInfo> shared) {
   ZoneScope zone_scope(DELETE_ON_EXIT);
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
 
   // Make sure we have an initial stack limit.
@@ skipping 45 matching lines @@
   // Set the expected number of properties for instances.
   SetExpectedNofPropertiesFromEstimate(shared, lit->expected_property_count());
 
   // Check the function has compiled code.
   ASSERT(shared->is_compiled());
   return true;
 }
 
 
 } }  // namespace v8::internal