Save and restore feedback from JIT.

runtime/vm/precompiler.h

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_PRECOMPILER_H_
 #define RUNTIME_VM_PRECOMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/hash_map.h"
 #include "vm/hash_table.h"
 #include "vm/object.h"
 
 namespace dart {
 
 // Forward declarations.
 class Class;
 class Error;
 class Field;
 class Function;
 class GrowableObjectArray;
 class RawError;
 class SequenceNode;
 class String;
+class ParsedJSONObject;
+class ParsedJSONArray;
+class Precompiler;
+class FlowGraph;
 
-
-class TypeRangeCache : public StackResource {
+class TypeRangeCache : public ValueObject {
  public:
-  TypeRangeCache(Thread* thread, intptr_t num_cids)
-      : StackResource(thread),
-        thread_(thread),
-        lower_limits_(thread->zone()->Alloc<intptr_t>(num_cids)),
-        upper_limits_(thread->zone()->Alloc<intptr_t>(num_cids)) {
-    for (intptr_t i = 0; i < num_cids; i++) {
-      lower_limits_[i] = kNotComputed;
-      upper_limits_[i] = kNotComputed;
-    }
-    // We don't re-enter the precompiler.
-    ASSERT(thread->type_range_cache() == NULL);
-    thread->set_type_range_cache(this);
-  }
-
-  ~TypeRangeCache() {
-    ASSERT(thread_->type_range_cache() == this);
-    thread_->set_type_range_cache(NULL);
-  }
+  TypeRangeCache(Precompiler* precompiler, Thread* thread, intptr_t num_cids);
+  ~TypeRangeCache();
 
   bool InstanceOfHasClassRange(const AbstractType& type,
                                intptr_t* lower_limit,
                                intptr_t* upper_limit);
 
  private:
   static const intptr_t kNotComputed = -1;
   static const intptr_t kNotContiguous = -2;
 
+  Precompiler* precompiler_;
   Thread* thread_;
   intptr_t* lower_limits_;
   intptr_t* upper_limits_;
 };
 
 
 class SymbolKeyValueTrait {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef const String* Key;
@@ skipping 256 matching lines @@
 
   void Print() const;
 
   const Field* field_;
   intptr_t cid_;
 };
 
 typedef DirectChainedHashMap<FieldTypePair> FieldTypeMap;
 
 
+struct IntptrPair {
+  // Typedefs needed for the DirectChainedHashMap template.
+  typedef intptr_t Key;
+  typedef intptr_t Value;
+  typedef IntptrPair Pair;
+
+  static Key KeyOf(Pair kv) { return kv.key_; }
+
+  static Value ValueOf(Pair kv) { return kv.value_; }
+
+  static inline intptr_t Hashcode(Key key) { return key; }
+
+  static inline bool IsKeyEqual(Pair pair, Key key) { return pair.key_ == key; }
+
+  IntptrPair(intptr_t key, intptr_t value) : key_(key), value_(value) {}
+
+  IntptrPair() : key_(kIllegalCid), value_(kIllegalCid) {}
+
+  Key key_;
+  Value value_;
+};
+
+typedef DirectChainedHashMap<IntptrPair> CidMap;
+
+
+struct FunctionFeedbackKey {
+  FunctionFeedbackKey() : owner_cid_(kIllegalCid), token_(0), kind_(0) {}
+  FunctionFeedbackKey(intptr_t owner_cid, intptr_t token, intptr_t kind)
+      : owner_cid_(owner_cid), token_(token), kind_(kind) {}
+
+  intptr_t owner_cid_;
+  intptr_t token_;
+  intptr_t kind_;
+};
+
+
+struct FunctionFeedbackPair {
+  // Typedefs needed for the DirectChainedHashMap template.
+  typedef FunctionFeedbackKey Key;
+  typedef ParsedJSONObject* Value;
+  typedef FunctionFeedbackPair Pair;
+
+  static Key KeyOf(Pair kv) { return kv.key_; }
+
+  static Value ValueOf(Pair kv) { return kv.value_; }
+
+  static inline intptr_t Hashcode(Key key) {
+    return key.token_ ^ key.owner_cid_;

[Florian Schneider, 2016/12/15 19:09:35]

Add kind_ to the computation?

+  }
+
+  static inline bool IsKeyEqual(Pair pair, Key key) {
+    return (pair.key_.owner_cid_ == key.owner_cid_) &&
+           (pair.key_.token_ == key.token_) && (pair.key_.kind_ == key.kind_);
+  }
+
+  FunctionFeedbackPair(Key key, Value value) : key_(key), value_(value) {}
+
+  FunctionFeedbackPair() : key_(), value_(NULL) {}
+
+  Key key_;
+  Value value_;
+};
+
+typedef DirectChainedHashMap<FunctionFeedbackPair> FunctionFeedbackMap;
+
+
 class Precompiler : public ValueObject {
  public:
   static RawError* CompileAll(
       Dart_QualifiedFunctionName embedder_entry_points[],
-      bool reset_fields);
+      bool reset_fields,
+      uint8_t* jit_feedback,
+      intptr_t jit_feedback_length);
 
   static RawError* CompileFunction(Precompiler* precompiler,
                                    Thread* thread,
                                    Zone* zone,
                                    const Function& function,
                                    FieldTypeMap* field_type_map = NULL);
 
   static RawObject* EvaluateStaticInitializer(const Field& field);
   static RawObject* ExecuteOnce(SequenceNode* fragment);
 
   static RawFunction* CompileStaticInitializer(const Field& field,
                                                bool compute_type);
 
   // Returns true if get:runtimeType is not overloaded by any class.
   bool get_runtime_type_is_unique() const {
     return get_runtime_type_is_unique_;
   }
 
   FieldTypeMap* field_type_map() { return &field_type_map_; }
+  TypeRangeCache* type_range_cache() { return type_range_cache_; }
+  void set_type_range_cache(TypeRangeCache* value) {
+    type_range_cache_ = value;
+  }
+
+  bool HasFeedback() const { return jit_feedback_ != NULL; }
+  void PopulateWithICData(const Function& func, FlowGraph* graph);
+  void TryApplyFeedback(ParsedJSONArray* js_icdatas, const ICData& ic);
 
  private:
   Precompiler(Thread* thread, bool reset_fields);
 
+  void LoadFeedback(uint8_t* jit_feedback, intptr_t jit_feedback_length);
+  ParsedJSONObject* LookupFeedback(const Function& function);
+
   void DoCompileAll(Dart_QualifiedFunctionName embedder_entry_points[]);
   void ClearAllCode();
   void AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]);
   void AddEntryPoints(Dart_QualifiedFunctionName entry_points[]);
   void Iterate();
 
   void AddType(const AbstractType& type);
   void AddTypesOf(const Class& cls);
   void AddTypesOf(const Function& function);
   void AddTypeArguments(const TypeArguments& args);
@@ skipping 27 matching lines @@
   void DedupStackMaps();
   void DedupLists();
   void DedupInstructions();
   void ResetPrecompilerState();
 
   void CollectDynamicFunctionNames();
 
   void PrecompileStaticInitializers();
   void PrecompileConstructors();
 
-  template <typename T>
-  class Visitor : public ValueObject {
-   public:
-    virtual ~Visitor() {}
-    virtual void Visit(const T& obj) = 0;
-  };
-  typedef Visitor<Function> FunctionVisitor;
-  typedef Visitor<Class> ClassVisitor;
-
-  void VisitFunctions(FunctionVisitor* visitor);
-  void VisitClasses(ClassVisitor* visitor);
-
   void FinalizeAllClasses();
   void SortClasses();
   void RemapClassIds(intptr_t* old_to_new_cid);
+  void VerifyJITFeedback();
+  RawScript* LookupScript(const char* uri);
+  intptr_t MapCid(intptr_t feedback_cid);
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return zone_; }
   Isolate* isolate() const { return isolate_; }
 
   Thread* thread_;
   Zone* zone_;
   Isolate* isolate_;
 
   const bool reset_fields_;
 
+  ParsedJSONObject* jit_feedback_;
+
   bool changed_;
   intptr_t function_count_;
   intptr_t class_count_;
   intptr_t selector_count_;
   intptr_t dropped_function_count_;
   intptr_t dropped_field_count_;
   intptr_t dropped_class_count_;
   intptr_t dropped_typearg_count_;
   intptr_t dropped_type_count_;
   intptr_t dropped_library_count_;
 
   GrowableObjectArray& libraries_;
   const GrowableObjectArray& pending_functions_;
   SymbolSet sent_selectors_;
   FunctionSet enqueued_functions_;
   FieldSet fields_to_retain_;
   FunctionSet functions_to_retain_;
   ClassSet classes_to_retain_;
   TypeArgumentsSet typeargs_to_retain_;
   AbstractTypeSet types_to_retain_;
   InstanceSet consts_to_retain_;
   FieldTypeMap field_type_map_;
+  TypeRangeCache* type_range_cache_;
+  CidMap feedback_cid_map_;
+  FunctionFeedbackMap function_feedback_map_;
   Error& error_;
 
   bool get_runtime_type_is_unique_;
 };
 
 
 class FunctionsTraits {
  public:
   static const char* Name() { return "FunctionsTraits"; }
   static bool ReportStats() { return false; }
@@ skipping 17 matching lines @@
   }
   static RawObject* NewKey(const Function& function) { return function.raw(); }
 };
 
 typedef UnorderedHashSet<FunctionsTraits> UniqueFunctionsSet;
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PRECOMPILER_H_