Added a EvalCache that caches eval'ed scripts and compiled function boilerpla...

src/heap.cc

 // Copyright 2006-2008 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:
 //
 //     * 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 417 matching lines @@
 
   gc_state_ = NOT_IN_GC;
 
   Shrink();
 
   Counters::objs_since_last_full.Set(0);
 }
 
 
 void Heap::MarkCompactPrologue() {
+  // Empty eval caches
+  Heap::eval_cache_global_ = Heap::null_value();
+  Heap::eval_cache_non_global_ = Heap::null_value();
+
   RegExpImpl::OldSpaceCollectionPrologue();
   Top::MarkCompactPrologue();
   ThreadManager::MarkCompactPrologue();
 }
 
 
 void Heap::MarkCompactEpilogue() {
   Top::MarkCompactEpilogue();
   ThreadManager::MarkCompactEpilogue();
 }
@@ skipping 739 matching lines @@
   // Allocate cache for single character strings.
   obj = AllocateFixedArray(String::kMaxAsciiCharCode+1);
   if (obj->IsFailure()) return false;
   single_character_string_cache_ = FixedArray::cast(obj);
 
   // Allocate cache for external strings pointing to native source code.
   obj = AllocateFixedArray(Natives::GetBuiltinsCount());
   if (obj->IsFailure()) return false;
   natives_source_cache_ = FixedArray::cast(obj);
 
+  // Initialized eval cache to null value.
+  eval_cache_global_ = null_value();
+  eval_cache_non_global_ = null_value();
+
   return true;
 }
 
 
 static inline int double_get_hash(double d) {
   DoubleRepresentation rep(d);
   return ((static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) &
           (Heap::kNumberStringCacheSize - 1));
 }
 
@@ skipping 1039 matching lines @@
   Object* symbol = NULL;
   Object* new_table =
       SymbolTable::cast(symbol_table_)->LookupString(string, &symbol);
   if (new_table->IsFailure()) return new_table;
   symbol_table_ = new_table;
   ASSERT(symbol != NULL);
   return symbol;
 }
 
 
+Object* Heap::LookupEvalCache(bool is_global_context, String* src) {
+  Object* cache = is_global_context ?
+      eval_cache_global_ : eval_cache_non_global_;
+  return cache == null_value() ?
+      null_value() : EvalCache::cast(cache)->Lookup(src);
+}
+
+
+Object* Heap::PutInEvalCache(bool is_global_context, String* src,
+                             JSFunction* value) {
+  Object** cache_ptr = is_global_context ?
+      &eval_cache_global_ : &eval_cache_non_global_;
+
+  if (*cache_ptr == null_value()) {
+    Object* obj = EvalCache::Allocate(kInitialEvalCacheSize);
+    if (obj->IsFailure()) return false;
+    *cache_ptr = obj;
+  }
+    
+  Object* new_cache =
+      EvalCache::cast(*cache_ptr)->Put(src, value);
+  if (new_cache->IsFailure()) return new_cache;
+  *cache_ptr = new_cache;
+
+  return value;
+}
+
+
 #ifdef DEBUG
 void Heap::ZapFromSpace() {
   ASSERT(HAS_HEAP_OBJECT_TAG(kFromSpaceZapValue));
   for (Address a = new_space_->FromSpaceLow();
        a < new_space_->FromSpaceHigh();
        a += kPointerSize) {
     Memory::Address_at(a) = kFromSpaceZapValue;
   }
 }
 #endif  // DEBUG
@@ skipping 695 matching lines @@
       return "Scavenge";
     case MARK_COMPACTOR:
       return MarkCompactCollector::HasCompacted() ? "Mark-compact"
                                                   : "Mark-sweep";
   }
   return "Unknown GC";
 }
 
 
 } }  // namespace v8::internal