Short term JSON eval cache

src/objects.h

 // Copyright 2012 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 61 matching lines @@
 //         - JSProxy
 //           - JSFunctionProxy
 //       - FixedArrayBase
 //         - ByteArray
 //         - FixedArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
 //             - SymbolTable
 //             - CompilationCacheTable
+//             - ShortTermJSONEvalCacheTable
 //             - CodeCacheHashTable
 //             - MapCache
 //           - Context
 //           - JSFunctionResultCache
 //           - ScopeInfo
 //           - TransitionArray
 //         - FixedDoubleArray
 //         - ExternalArray
 //           - ExternalPixelArray
 //           - ExternalByteArray
@@ skipping 751 matching lines @@
   V(JSSet)                                     \
   V(JSMap)                                     \
   V(JSWeakMap)                                 \
   V(JSRegExp)                                  \
   V(HashTable)                                 \
   V(Dictionary)                                \
   V(SymbolTable)                               \
   V(JSFunctionResultCache)                     \
   V(NormalizedMapCache)                        \
   V(CompilationCacheTable)                     \
+  V(ShortTermJSONEvalCacheTable)               \
   V(CodeCacheHashTable)                        \
   V(PolymorphicCodeCacheHashTable)             \
   V(MapCache)                                  \
   V(Primitive)                                 \
   V(GlobalObject)                              \
   V(JSGlobalObject)                            \
   V(JSBuiltinsObject)                          \
   V(JSGlobalProxy)                             \
   V(UndetectableObject)                        \
   V(AccessCheckNeeded)                         \
@@ skipping 4849 matching lines @@
 
   // Indicates that the function cannot be optimized.
   DECL_BOOLEAN_ACCESSORS(dont_optimize)
 
   // Indicates that the function cannot be inlined.
   DECL_BOOLEAN_ACCESSORS(dont_inline)
 
   // Indicates that code for this function cannot be cached.
   DECL_BOOLEAN_ACCESSORS(dont_cache)
 
+  // Indicates this is an eval function which just returns an object or array
+  // literal containing no outside information.
+  DECL_BOOLEAN_ACCESSORS(is_json_eval)
+
   // Indicates whether or not the code in the shared function support
   // deoptimization.
   inline bool has_deoptimization_support();
 
   // Enable deoptimization support through recompiled code.
   void EnableDeoptimizationSupport(Code* recompiled);
 
   // Disable (further) attempted optimization of all functions sharing this
   // shared function info.
   void DisableOptimization(const char* reason);
@@ skipping 213 matching lines @@
     kUsesArguments,
     kHasDuplicateParameters,
     kNative,
     kBoundFunction,
     kIsAnonymous,
     kNameShouldPrintAsAnonymous,
     kIsFunction,
     kDontOptimize,
     kDontInline,
     kDontCache,
+    kIsJSONEval,
     kCompilerHintsCount  // Pseudo entry
   };
 
   class DeoptCountBits: public BitField<int, 0, 4> {};
   class OptReenableTriesBits: public BitField<int, 4, 18> {};
   class ICAgeBits: public BitField<int, 22, 8> {};
 
  private:
 #if V8_HOST_ARCH_32_BIT
   // On 32 bit platforms, compiler hints is a smi.
@@ skipping 797 matching lines @@
   Object* Lookup(String* src, Context* context);
   Object* LookupEval(String* src,
                      Context* context,
                      LanguageMode language_mode,
                      int scope_position);
   Object* LookupRegExp(String* source, JSRegExp::Flags flags);
   MUST_USE_RESULT MaybeObject* Put(String* src,
                                    Context* context,
                                    Object* value);
   MUST_USE_RESULT MaybeObject* PutEval(String* src,
-                                       Context* context,
-                                       SharedFunctionInfo* value,
-                                       int scope_position);
+                       Context* context,
+                       SharedFunctionInfo* value,
+                       int scope_position);
   MUST_USE_RESULT MaybeObject* PutRegExp(String* src,
                                          JSRegExp::Flags flags,
                                          FixedArray* value);
+  MUST_USE_RESULT MaybeObject* PutRaw(Object* key,
+                                      SharedFunctionInfo* value,
+                                      HashTableKey* hasher);
 
   // Remove given value from cache.
   void Remove(Object* value);
 
   static inline CompilationCacheTable* cast(Object* obj);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheTable);
 };
 
 
+class ShortTermJSONEvalCacheShape : public BaseShape<HashTableKey*> {
+ public:
+  static inline bool IsMatch(HashTableKey* key, Object* value) {
+    return key->IsMatch(value);
+  }
+
+  static inline uint32_t Hash(HashTableKey* key) {
+    return key->Hash();
+  }
+
+  static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
+    return key->HashForObject(object);
+  }
+
+  MUST_USE_RESULT static MaybeObject* AsObject(HashTableKey* key) {
+    return key->AsObject();
+  }
+
+  // This is the prefix size in the HashTable class. We don't reference it
+  // directly because clang is picky about the order constants are defined.
+  static const int kPrefixStartIndex = 3;
+  static const int kTotalSourceSizeIndex = kPrefixStartIndex;
+  static const int kAgeIndex = kTotalSourceSizeIndex + 1;
+
+  static const int kPrefixSize = kAgeIndex - kPrefixStartIndex + 1;
+  static const int kEntrySize = 3;
+};
+
+
+class ShortTermJSONEvalCacheTable
+  : public HashTable<ShortTermJSONEvalCacheShape, HashTableKey*> {
+ public:
+  MUST_USE_RESULT static MaybeObject* Allocate();
+
+  // Returns the total code size of all entries
+  int total_source_size();
+
+  // Find a cached value, otherwise return undefined.
+  Object* Lookup(String* src);
+
+  // Attempt to add a new value to the cache. The size of the value (as given
+  // by ValueSize) must be at most kMaxTotalSourceSize. This may evict
+  // older elements to make room for the new element.
+  MUST_USE_RESULT MaybeObject* Put(String* src,
+                                   SharedFunctionInfo* value);
+
+  // Remove given value from cache.
+  void Remove(Object* value);
+
+  // Return the code size of a value. Values must be less than kMaxTotalCodeSize
+  // to be added to this cache.
+  static int ValueSize(SharedFunctionInfo* value);
+
+  static inline ShortTermJSONEvalCacheTable* cast(Object* obj);
+
+  static int max_entries();
+  static int max_total_source_size();
+
+ private:
+  void Reserve(int size);
+  void RemoveOldest();
+
+  void set_total_source_size(int size);
+
+  int current_age();
+  void set_current_age(int age);
+  Smi* NextAge();
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ShortTermJSONEvalCacheTable);
+};
+
+
 class CodeCache: public Struct {
  public:
   DECL_ACCESSORS(default_cache, FixedArray)
   DECL_ACCESSORS(normal_type_cache, Object)
 
   // Add the code object to the cache.
   MUST_USE_RESULT MaybeObject* Update(String* name, Code* code);
 
   // Lookup code object in the cache. Returns code object if found and undefined
   // if not.
@@ skipping 2220 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_