src/hotspot/share/ci/ciObjectFactory.cpp

@@ -41,15 +41,17 @@
  #include "ci/ciTypeArray.hpp"
  #include "ci/ciTypeArrayKlass.hpp"
  #include "ci/ciUtilities.inline.hpp"
  #include "classfile/javaClasses.inline.hpp"
  #include "classfile/vmClasses.hpp"
+ #include "compiler/compileTask.hpp"
  #include "compiler/compiler_globals.hpp"
  #include "gc/shared/collectedHeap.inline.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/universe.hpp"
  #include "oops/oop.inline.hpp"
+ #include "oops/trainingData.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/signature.hpp"
  #include "utilities/macros.hpp"
  
  // ciObjectFactory

@@ -230,30 +232,44 @@
  // already been created, it is returned.  Otherwise, a new ciObject
  // is created.
  ciObject* ciObjectFactory::get(oop key) {
    ASSERT_IN_VM;
  
-   assert(Universe::heap()->is_in(key), "must be");
+   Handle keyHandle(Thread::current(), key);
+   assert(Universe::heap()->is_in(keyHandle()), "must be");
  
-   NonPermObject* &bucket = find_non_perm(key);
+   NonPermObject* &bucket = find_non_perm(keyHandle);
    if (bucket != nullptr) {
      return bucket->object();
    }
  
    // The ciObject does not yet exist.  Create it and insert it
    // into the cache.
-   Handle keyHandle(Thread::current(), key);
    ciObject* new_object = create_new_object(keyHandle());
    assert(keyHandle() == new_object->get_oop(), "must be properly recorded");
    init_ident_of(new_object);
    assert(Universe::heap()->is_in(new_object->get_oop()), "must be");
  
    // Not a perm-space object.
-   insert_non_perm(bucket, keyHandle(), new_object);
+   insert_non_perm(bucket, keyHandle, new_object);
+   notice_new_object(new_object);
    return new_object;
  }
  
+ void ciObjectFactory::notice_new_object(ciBaseObject* new_object) {
+   if (TrainingData::need_data()) {
+     ciEnv* env = ciEnv::current();
+     if (env->task() != nullptr) {
+       // Note: task will be null during init_compiler_runtime.
+       CompileTrainingData* td = env->task()->training_data();
+       if (td != nullptr) {
+         td->notice_jit_observation(env, new_object);
+       }
+     }
+   }
+ }
+ 
  int ciObjectFactory::metadata_compare(Metadata* const& key, ciMetadata* const& elt) {
    Metadata* value = elt->constant_encoding();
    if (key < value)      return -1;
    else if (key > value) return 1;
    else                  return 0;

@@ -329,10 +345,11 @@
        // into the table.  We need to recompute our index.
        index = _ci_metadata.find_sorted<Metadata*, ciObjectFactory::metadata_compare>(key, found);
      }
      assert(!found, "no double insert");
      _ci_metadata.insert_before(index, new_object);
+     notice_new_object(new_object);
      return new_object;
    }
    return _ci_metadata.at(index)->as_metadata();
  }
  

@@ -634,16 +651,16 @@
  // ciObjectFactory::find_non_perm
  //
  // Use a small hash table, hashed on the klass of the key.
  // If there is no entry in the cache corresponding to this oop, return
  // the null tail of the bucket into which the oop should be inserted.
- ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(oop key) {
-   assert(Universe::heap()->is_in(key), "must be");
-   ciMetadata* klass = get_metadata(key->klass());
+ ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(Handle keyHandle) {
+   assert(Universe::heap()->is_in(keyHandle()), "must be");
+   ciMetadata* klass = get_metadata(keyHandle->klass()); // This may safepoint!
    NonPermObject* *bp = &_non_perm_bucket[(unsigned) klass->hash() % NON_PERM_BUCKETS];
    for (NonPermObject* p; (p = (*bp)) != nullptr; bp = &p->next()) {
-     if (is_equal(p, key))  break;
+     if (is_equal(p, keyHandle()))  break;
    }
    return (*bp);
  }
  
  

@@ -662,16 +679,16 @@
  
  // ------------------------------------------------------------------
  // ciObjectFactory::insert_non_perm
  //
  // Insert a ciObject into the non-perm table.
- void ciObjectFactory::insert_non_perm(ciObjectFactory::NonPermObject* &where, oop key, ciObject* obj) {
-   assert(Universe::heap()->is_in_or_null(key), "must be");
+ void ciObjectFactory::insert_non_perm(ciObjectFactory::NonPermObject* &where, Handle keyHandle, ciObject* obj) {
+   assert(Universe::heap()->is_in_or_null(keyHandle()), "must be");
    assert(&where != &emptyBucket, "must not try to fill empty bucket");
-   NonPermObject* p = new (arena()) NonPermObject(where, key, obj);
-   assert(where == p && is_equal(p, key) && p->object() == obj, "entry must match");
-   assert(find_non_perm(key) == p, "must find the same spot");
+   NonPermObject* p = new (arena()) NonPermObject(where, keyHandle(), obj);
+   assert(where == p && is_equal(p, keyHandle()) && p->object() == obj, "entry must match");
+   assert(find_non_perm(keyHandle) == p, "must find the same spot");
    ++_non_perm_count;
  }
  
  // ------------------------------------------------------------------
  // ciObjectFactory::vm_symbol_at