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

src/objects.h

 // 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 596 matching lines @@
   inline bool IsCode();
   inline bool IsOddball();
   inline bool IsSharedFunctionInfo();
   inline bool IsJSValue();
   inline bool IsProxy();
   inline bool IsBoolean();
   inline bool IsJSArray();
   inline bool IsHashTable();
   inline bool IsDictionary();
   inline bool IsSymbolTable();
+  inline bool IsEvalCache();
   inline bool IsPrimitive();
   inline bool IsGlobalObject();
   inline bool IsJSGlobalObject();
   inline bool IsJSBuiltinsObject();
   inline bool IsUndetectableObject();
   inline bool IsAccessCheckNeeded();
 
   // Returns true if this object is an instance of the specified
   // function template.
   bool IsInstanceOf(FunctionTemplateInfo* type);
@@ skipping 1047 matching lines @@
 // encountered and stops when unused elements are encountered.
 //
 // - Elements with key == undefined have not been used yet.
 // - Elements with key == null have been deleted.
 //
 // The hash table class is parameterized with a prefix size and with
 // the size, including the key size, of the elements held in the hash
 // table.  The prefix size indicates an amount of memory in the
 // beginning of the backing storage that can be used for non-element
 // information by subclasses.
+
+// HashTableKey is an abstract superclass keys.
+class HashTableKey {
+ public:
+  // Returns whether the other object matches this key.
+  virtual bool IsMatch(Object* other) = 0;
+  typedef uint32_t (*HashFunction)(Object* obj);
+  // Returns the hash function used for this key.
+  virtual HashFunction GetHashFunction() = 0;
+  // Returns the hash value for this key.
+  virtual uint32_t Hash() = 0;
+  // Returns the key object for storing into the dictionary.
+  // If allocations fails a failure object is returned.
+  virtual Object* GetObject() = 0;
+  virtual bool IsStringKey() = 0;
+  // Required.
+  virtual ~HashTableKey() {}
+};
+
+
 template<int prefix_size, int element_size>
 class HashTable: public FixedArray {
  public:
   // Returns the number of elements in the dictionary.
   int NumberOfElements() {
     return Smi::cast(get(kNumberOfElementsIndex))->value();
   }
 
   // Returns the capacity of the dictionary.
   int Capacity() {
@@ skipping 21 matching lines @@
     return !k->IsNull() && !k->IsUndefined();
   }
 
   // Garbage collection support.
   void IteratePrefix(ObjectVisitor* visitor);
   void IterateElements(ObjectVisitor* visitor);
 
   // Casting.
   static inline HashTable* cast(Object* obj);
 
-  // Key is an abstract superclass keys.
-  class Key {
-   public:
-    // Returns whether the other object matches this key.
-    virtual bool IsMatch(Object* other) = 0;
-    typedef uint32_t (*HashFunction)(Object* obj);
-    // Returns the hash function used for this key.
-    virtual HashFunction GetHashFunction() = 0;
-    // Returns the hash value for this key.
-    virtual uint32_t Hash() = 0;
-    // Returns the key object for storing into the dictionary.
-    // If allocations fails a failure object is returned.
-    virtual Object* GetObject() = 0;
-    virtual bool IsStringKey() = 0;
-    // Required.
-    virtual ~Key() {}
-  };
-
   // Compute the probe offset (quadratic probing).
   INLINE(static uint32_t GetProbeOffset(uint32_t n)) {
     return (n + n * n) >> 1;
   }
 
   static const int kNumberOfElementsIndex = 0;
   static const int kCapacityIndex         = 1;
   static const int kPrefixStartIndex      = 2;
   static const int kElementsStartIndex    = kPrefixStartIndex + prefix_size;
   static const int kElementSize           = element_size;
   static const int kElementsStartOffset   =
       kHeaderSize + kElementsStartIndex * kPointerSize;
 
  protected:
   // Find entry for key otherwise return -1.
-  int FindEntry(Key* key);
+  int FindEntry(HashTableKey* key);
 
   // Find the entry at which to insert element with the given key that
   // has the given hash value.
   uint32_t FindInsertionEntry(Object* key, uint32_t hash);
 
   // Returns the index for an entry (of the key)
   static inline int EntryToIndex(int entry) {
     return (entry * kElementSize) + kElementsStartIndex;
   }
 
@@ skipping 12 matching lines @@
   }
 
 
   // Returns probe entry.
   static uint32_t GetProbe(uint32_t hash, uint32_t number, uint32_t size) {
     ASSERT(IsPowerOf2(size));
     return (hash + GetProbeOffset(number)) & (size - 1);
   }
 
   // Ensure enough space for n additional elements.
-  Object* EnsureCapacity(int n, Key* key);
+  Object* EnsureCapacity(int n, HashTableKey* key);
 };
 
 
 // SymbolTable.
 //
 // No special elements in the prefix and the element size is 1
 // because only the symbol itself (the key) needs to be stored.
 class SymbolTable: public HashTable<0, 1> {
  public:
   // Find symbol in the symbol table.  If it is not there yet, it is
   // added.  The return value is the symbol table which might have
   // been enlarged.  If the return value is not a failure, the symbol
   // pointer *s is set to the symbol found.
   Object* LookupSymbol(Vector<const char> str, Object** s);
   Object* LookupString(String* key, Object** s);
 
   // Casting.
   static inline SymbolTable* cast(Object* obj);
 
  private:
-  Object* LookupKey(Key* key, Object** s);
-  class Utf8Key;   // Key based on utf8 string.
-  class StringKey;  // Key based on String*.
+  Object* LookupKey(HashTableKey* key, Object** s);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SymbolTable);
 };
 
 
+// EvalCache for caching eval'ed string and function.

[Kasper Lund, 2008/09/05 09:16:29]

Rename to CompilationCacheTable?

[Feng Qian, 2008/09/09 03:42:50]

Done.

+//
+// The cache is cleaned up during a mark-compact GC.
+class EvalCache: public HashTable<0, 2> {
+ public:
+  // Find cached value for a string key, otherwise return null.
+  Object* Lookup(String* src);
+  Object* Put(String* src, Object* value);
+
+  static inline EvalCache* cast(Object* obj);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(EvalCache);
+};
+
+
 // Dictionary for keeping properties and elements in slow case.
 //
 // One element in the prefix is used for storing non-element
 // information about the dictionary.
 //
 // The rest of the array embeds triples of (key, value, details).
 // if key == undefined the triple is empty.
 // if key == null the triple has been deleted.
 // otherwise key contains the name of a property.
 class DictionaryBase: public HashTable<2, 3> {};
@@ skipping 87 matching lines @@
   }
 
   int NextEnumerationIndex() {
     return Smi::cast(get(kNextEnumnerationIndexIndex))->value();
   }
 
   // Returns a new array for dictionary usage. Might return Failure.
   static Object* Allocate(int at_least_space_for);
 
   // Ensure enough space for n additional elements.
-  Object* EnsureCapacity(int n, Key* key);
+  Object* EnsureCapacity(int n, HashTableKey* key);
 
 #ifdef DEBUG
   void Print();
 #endif
   // Returns the key (slow).
   Object* SlowReverseLookup(Object* value);
 
   // Bit masks.
   static const int kRequiresSlowElementsMask = 1;
   static const int kRequiresSlowElementsTagSize = 1;
   static const uint32_t kRequiresSlowElementsLimit = (1 << 29) - 1;
 
  private:
   // Generic at put operation.
-  Object* AtPut(Key* key, Object* value);
+  Object* AtPut(HashTableKey* key, Object* value);
 
-  Object* Add(Key* key, Object* value, PropertyDetails details);
+  Object* Add(HashTableKey* key, Object* value, PropertyDetails details);
 
   // Add entry to dictionary.
   void AddEntry(Object* key,
                 Object* value,
                 PropertyDetails details,
                 uint32_t hash);
 
   // Sets the entry to (key, value) pair.
   inline void SetEntry(int entry,
                        Object* key,
                        Object* value,
                        PropertyDetails details);
 
   void UpdateMaxNumberKey(uint32_t key);
 
   // Generate new enumneration indices to avoid enumeration insdex overflow.
   Object* GenerateNewEnumerationIndices();
 
   static const int kMaxNumberKeyIndex = kPrefixStartIndex;
   static const int kNextEnumnerationIndexIndex = kMaxNumberKeyIndex + 1;
 
-  class NumberKey;  // Key containing uint32_t.
-  class StringKey;  // Key containing String*.
-
   DISALLOW_IMPLICIT_CONSTRUCTORS(Dictionary);
 };
 
 
 // ByteArray represents fixed sized byte arrays.  Used by the outside world,
 // such as PCRE, and also by the memory allocator and garbage collector to
 // fill in free blocks in the heap.
 class ByteArray: public Array {
  public:
   // Setter and getter.
@@ skipping 1855 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_