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

src/heap.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 104 matching lines @@
   V(Proxy, prototype_accessors)                         \
   V(JSObject, debug_event_listeners)                    \
   V(Dictionary, code_stubs)                             \
   V(Dictionary, non_monomorphic_cache)                  \
   V(Code, js_entry_code)                                \
   V(Code, js_construct_entry_code)                      \
   V(Code, c_entry_code)                                 \
   V(Code, c_entry_debug_break_code)                     \
   V(FixedArray, number_string_cache)                    \
   V(FixedArray, single_character_string_cache)          \
-  V(FixedArray, natives_source_cache)
+  V(FixedArray, natives_source_cache)                   \
+  V(Object, eval_cache_global)                          \
+  V(Object, eval_cache_non_global)
 
 #define ROOT_LIST(V)                                  \
   STRONG_ROOT_LIST(V)                                 \
   V(Object, symbol_table)
 
 #define SYMBOL_LIST(V)                                                   \
   V(Array_symbol, "Array")                                               \
   V(Object_symbol, "Object")                                             \
   V(Proto_symbol, "__proto__")                                           \
   V(StringImpl_symbol, "StringImpl")                                     \
@@ skipping 390 matching lines @@
   // If not found, a new symbol is added to the table and returned.
   // Returns Failure::RetryAfterGC(requested_bytes, space) if allocation
   // failed.
   // Please note this function does not perform a garbage collection.
   static Object* LookupSymbol(Vector<const char> str);
   static Object* LookupAsciiSymbol(const char* str) {
     return LookupSymbol(CStrVector(str));
   }
   static Object* LookupSymbol(String* str);
 
+  // EvalCache caches function boilerplates for compiled scripts

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

I would move this code out into a separate class with static operations;
something like CompilationCache maybe?

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

Let's do that in our next step. Also I'd like to see the cache performance for
whole compilation.
Another thing is that we might be able to use 1 element cache since the cached
function has source code already.
Also we may want to cache shared function info instead of the function.

+  // from 'eval' function.
+  // Source string is used as the key, and compiled function
+  // boilerplate as value. Because the same source has different
+  // compiled code in global or local context, we use separate
+  // caches for global and local contexts.
+  // Caches are cleared before mark-compact GC's.

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

Isn't this really for all mark-sweep GCs - not just the compacting ones?

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

Both, but since we use the same name Heap::MarkCompact. I probably should say
'global GC'.

+
+  // Finds the function boilerplate of a source string.
+  // It returns a JSFunction object if found in the cache.
+  // The first parameter specifies whether the code is
+  // compiled in a global context.
+  static Object* LookupEvalCache(bool is_global_context, String* src);
+
+  // Put a source string and its compiled function boilerplate
+  // in the eval cache.  The cache may expand, and returns failure
+  // if it cannot expand the cache, otherwise the value is returned.
+  // The first parameter specifies whether the boilerplate is
+  // compiled in a global context. 
+  static Object* PutInEvalCache(bool is_global_context,

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

Indentation of the arguments should align them below each other.

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

Done.

+       String* src, JSFunction* value);
+
   // Compute the matching symbol map for a string if possible.
   // NULL is returned if string is in new space or not flattened.
   static Map* SymbolMapForString(String* str);
 
   // Converts the given boolean condition to JavaScript boolean value.
   static Object* ToBoolean(bool condition) {
     return condition ? true_value() : false_value();
   }
 
   // Code that should be run before and after each GC.  Includes some
@@ skipping 312 matching lines @@
   // Update an old object's remembered set
   static int UpdateRSet(HeapObject* obj);
 
   // Rebuild remembered set in an old space.
   static void RebuildRSets(PagedSpace* space);
 
   // Rebuild remembered set in the large object space.
   static void RebuildRSets(LargeObjectSpace* space);
 
   static const int kInitialSymbolTableSize = 2048;
+  static const int kInitialEvalCacheSize = 64;
 
   friend class Factory;
   friend class DisallowAllocationFailure;
 };
 
 
 #ifdef DEBUG
 // Visitor class to verify interior pointers that do not have remembered set
 // bits.  All heap object pointers have to point into the heap to a location
 // that has a map pointer at its first word.  Caveat: Heap::Contains is an
@@ skipping 247 matching lines @@
   // On a full GC, a count of the number of marked objects.  Incremented
   // when an object is marked and decremented when an object's mark bit is
   // cleared.  Will be zero on a scavenge collection.
   int marked_count_;
 
   // The count from the end of the previous full GC.  Will be zero if there
   // was no previous full GC.
   int previous_marked_count_;
 };
 
-
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_