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

src/objects.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 5215 matching lines @@
 
 
 int JSObject::GetEnumElementKeys(FixedArray* storage) {
   return GetLocalElementKeys(storage,
                              static_cast<PropertyAttributes>(DONT_ENUM));
 }
 
 
 // The NumberKey uses carries the uint32_t as key.
 // This avoids allocation in HasProperty.
-class Dictionary::NumberKey : public Dictionary::Key {
+class NumberKey : public HashTableKey {
  public:
   explicit NumberKey(uint32_t number) {
     number_ = number;
   }
 
  private:
   bool IsMatch(Object* other) {
     return number_ == ToUint32(other);
   }
 
@@ skipping 25 matching lines @@
   static uint32_t ToUint32(Object* obj) {
     ASSERT(obj->IsNumber());
     return static_cast<uint32_t>(obj->Number());
   }
 
   bool IsStringKey() { return false; }
 
   uint32_t number_;
 };
 
+
 // StringKey simply carries a string object as key.
-class Dictionary::StringKey : public Dictionary::Key {
+class StringKey : public HashTableKey {
  public:
   explicit StringKey(String* string) {
     string_ = string;
   }
 
- private:
   bool IsMatch(Object* other) {
     if (!other->IsString()) return false;
     return string_->Equals(String::cast(other));
   }
 
   uint32_t Hash() { return StringHash(string_); }
 
   HashFunction GetHashFunction() { return StringHash; }
 
   Object* GetObject() { return string_; }
 
   static uint32_t StringHash(Object* obj) {
     return String::cast(obj)->Hash();
   }
 
   bool IsStringKey() { return true; }
 
   String* string_;
 };
 
-// Utf8Key carries a vector of chars as key.
-class SymbolTable::Utf8Key : public SymbolTable::Key {
+// Utf8SymbolKey carries a vector of chars as key.
+class Utf8SymbolKey : public HashTableKey {
  public:
-  explicit Utf8Key(Vector<const char> string)
+  explicit Utf8SymbolKey(Vector<const char> string)
       : string_(string), hash_(0) { }
 
   bool IsMatch(Object* other) {
     if (!other->IsString()) return false;
     return String::cast(other)->IsEqualTo(string_);
   }
 
   HashFunction GetHashFunction() {
     return StringHash;
   }
@@ skipping 19 matching lines @@
   }
 
   bool IsStringKey() { return true; }
 
   Vector<const char> string_;
   uint32_t hash_;
   int chars_;  // Caches the number of characters when computing the hash code.
 };
 
 
-// StringKey carries a string object as key.
-class SymbolTable::StringKey : public SymbolTable::Key {
+// SymbolKey carries a string/symbol object as key.
+class SymbolKey : public HashTableKey {
  public:
-  explicit StringKey(String* string) : string_(string) { }
+  explicit SymbolKey(String* string) : string_(string) { }
 
   HashFunction GetHashFunction() {
     return StringHash;
   }
 
   bool IsMatch(Object* other) {
     if (!other->IsString()) return false;
     return String::cast(other)->Equals(string_);
   }
 
@@ skipping 43 matching lines @@
   if (!obj->IsFailure()) {
     HashTable::cast(obj)->SetNumberOfElements(0);
     HashTable::cast(obj)->SetCapacity(capacity);
   }
   return obj;
 }
 
 
 // Find entry for key otherwise return -1.
 template <int prefix_size, int element_size>
-int HashTable<prefix_size, element_size>::FindEntry(Key* key) {
+int HashTable<prefix_size, element_size>::FindEntry(HashTableKey* key) {
   uint32_t nof = NumberOfElements();
   if (nof == 0) return -1;  // Bail out if empty.
 
   uint32_t capacity = Capacity();
   uint32_t hash = key->Hash();
   uint32_t entry = GetProbe(hash, 0, capacity);
 
   Object* element = KeyAt(entry);
   uint32_t passed_elements = 0;
   if (!element->IsNull()) {
     if (!element->IsUndefined() && key->IsMatch(element)) return entry;
     if (++passed_elements == nof) return -1;
   }
   for (uint32_t i = 1; !element->IsUndefined(); i++) {
     entry = GetProbe(hash, i, capacity);
     element = KeyAt(entry);
     if (!element->IsNull()) {
       if (!element->IsUndefined() && key->IsMatch(element)) return entry;
       if (++passed_elements == nof) return -1;
     }
   }
   return -1;
 }
 
 
 template<int prefix_size, int element_size>
-Object* HashTable<prefix_size, element_size>::EnsureCapacity(int n, Key* key) {
+Object* HashTable<prefix_size, element_size>::EnsureCapacity(
+    int n, HashTableKey* key) {
   int capacity = Capacity();
   int nof = NumberOfElements() + n;
   // Make sure 20% is free
   if (nof + (nof >> 2) <= capacity) return this;
 
   Object* obj = Allocate(nof * 2);
   if (obj->IsFailure()) return obj;
   HashTable* dict = HashTable::cast(obj);
   WriteBarrierMode mode = dict->GetWriteBarrierMode();
 
@@ skipping 37 matching lines @@
 
 
 // Force instantiation of SymbolTable's base class
 template class HashTable<0, 1>;
 
 
 // Force instantiation of Dictionary's base class
 template class HashTable<2, 3>;
 
 
+// Force instantiation of EvalCache's base class
+template class HashTable<0, 2>;
+
+
 Object* SymbolTable::LookupString(String* string, Object** s) {
-  StringKey key(string);
+  SymbolKey key(string);
   return LookupKey(&key, s);
 }
 
 
 Object* SymbolTable::LookupSymbol(Vector<const char> str, Object** s) {
-  Utf8Key key(str);
+  Utf8SymbolKey key(str);
   return LookupKey(&key, s);
 }
 
 
-Object* SymbolTable::LookupKey(Key* key, Object** s) {
+Object* SymbolTable::LookupKey(HashTableKey* key, Object** s) {
   int entry = FindEntry(key);
 
   // Symbol already in table.
   if (entry != -1) {
     *s = KeyAt(entry);
     return this;
   }
 
   // Adding new symbol. Grow table if needed.
   Object* obj = EnsureCapacity(1, key);
@@ skipping 10 matching lines @@
 
   // Add the new symbol and return it along with the symbol table.
   entry = table->FindInsertionEntry(symbol, key->Hash());
   table->set(EntryToIndex(entry), symbol);
   table->ElementAdded();
   *s = symbol;
   return table;
 }
 
 
+Object* EvalCache::Lookup(String* src) {
+  StringKey key(src);
+  int entry = FindEntry(&key);
+  if (entry != -1) {
+    return get(EntryToIndex(entry) + 1);
+  } else {
+    return Heap::undefined_value();
+  }
+}
+
+
+Object* EvalCache::Put(String* src, Object* value) {
+  StringKey key(src);
+  Object* obj = EnsureCapacity(1, &key);
+  if (obj->IsFailure()) return obj;
+
+  EvalCache* cache = reinterpret_cast<EvalCache*>(obj);
+  int entry = cache->FindInsertionEntry(src, key.Hash());
+  cache->set(EntryToIndex(entry), src);
+  cache->set(EntryToIndex(entry) + 1, value);
+  cache->ElementAdded();
+  return cache;
+}
+
+
 Object* Dictionary::Allocate(int at_least_space_for) {
   Object* obj = DictionaryBase::Allocate(at_least_space_for);
   // Initialize the next enumeration index.
   if (!obj->IsFailure()) {
     Dictionary::cast(obj)->
         SetNextEnumerationIndex(PropertyDetails::kInitialIndex);
   }
   return obj;
 }
 
@@ skipping 42 matching lines @@
       DetailsAtPut(i, new_details);
     }
   }
 
   // Set the next enumeration index.
   SetNextEnumerationIndex(PropertyDetails::kInitialIndex+length);
   return this;
 }
 
 
-Object* Dictionary::EnsureCapacity(int n, Key* key) {
+Object* Dictionary::EnsureCapacity(int n, HashTableKey* key) {
   // Check whether there are enough enumeration indices to add n elements.
   if (key->IsStringKey() &&
       !PropertyDetails::IsValidIndex(NextEnumerationIndex() + n)) {
     // If not, we generate new indices for the properties.
     Object* result = GenerateNewEnumerationIndices();
     if (result->IsFailure()) return result;
   }
   return DictionaryBase::EnsureCapacity(n, key);
 }
 
@@ skipping 35 matching lines @@
   return FindEntry(&k);
 }
 
 
 int Dictionary::FindNumberEntry(uint32_t index) {
   NumberKey k(index);
   return FindEntry(&k);
 }
 
 
-Object* Dictionary::AtPut(Key* key, Object* value) {
+Object* Dictionary::AtPut(HashTableKey* key, Object* value) {
   int entry = FindEntry(key);
 
   // If the entry is present set the value;
   if (entry != -1) {
     ValueAtPut(entry, value);
     return this;
   }
 
   // Check whether the dictionary should be extended.
   Object* obj = EnsureCapacity(1, key);
   if (obj->IsFailure()) return obj;
   Object* k = key->GetObject();
   if (k->IsFailure()) return k;
   PropertyDetails details = PropertyDetails(NONE, NORMAL);
   Dictionary::cast(obj)->AddEntry(k, value, details, key->Hash());
   return obj;
 }
 
 
-Object* Dictionary::Add(Key* key, Object* value, PropertyDetails details) {
+Object* Dictionary::Add(HashTableKey* key, Object* value,
+                        PropertyDetails details) {
   // Check whether the dictionary should be extended.
   Object* obj = EnsureCapacity(1, key);
   if (obj->IsFailure()) return obj;
   // Compute the key object.
   Object* k = key->GetObject();
   if (k->IsFailure()) return k;
   Dictionary::cast(obj)->AddEntry(k, value, details, key->Hash());
   return obj;
 }
 
@@ skipping 506 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal