src/hotspot/share/oops/trainingData.hpp

*** 34,10 ***
--- 34,11 ---
  #include "oops/instanceKlass.hpp"
  #include "oops/method.hpp"
  #include "oops/objArrayKlass.hpp"
  #include "runtime/handles.hpp"
  #include "runtime/mutexLocker.hpp"
+ #include "utilities/count_leading_zeros.hpp"
  #include "utilities/resizableHashTable.hpp"
  
  class ciEnv;
  class ciBaseObject;
  class CompileTask;

*** 307,12 ***
    static void iterate(const Function& fn) { iterate(const_cast<Function&>(fn)); }
  
    template<typename Function>
    static void iterate(Function& fn) { // lambda enabled API
      TrainingDataLocker l;
!     if (have_data()) {
!       archived_training_data_dictionary()->iterate(fn);
      }
      if (need_data()) {
        training_data_set()->iterate(fn);
      }
    }
--- 308,12 ---
    static void iterate(const Function& fn) { iterate(const_cast<Function&>(fn)); }
  
    template<typename Function>
    static void iterate(Function& fn) { // lambda enabled API
      TrainingDataLocker l;
!     if (have_data() && !need_data()) {
!       archived_training_data_dictionary()->iterate_all([&](TrainingData* td) { fn(td); });
      }
      if (need_data()) {
        training_data_set()->iterate(fn);
      }
    }

*** 327,18 ***
    virtual void prepare(Visitor& visitor) = 0;
    virtual void cleanup(Visitor& visitor) = 0;
  
    static void initialize() NOT_CDS_RETURN;
  
!   static void verify();
  
    // Widget for recording dependencies, as an N-to-M graph relation,
    // possibly cyclic.
    template<typename E>
    class DepList : public StackObj {
      GrowableArrayCHeap<E, mtCompiler>* _deps_dyn;
      Array<E>*                          _deps;
    public:
      DepList() {
        _deps_dyn = nullptr;
        _deps = nullptr;
      }
--- 328,31 ---
    virtual void prepare(Visitor& visitor) = 0;
    virtual void cleanup(Visitor& visitor) = 0;
  
    static void initialize() NOT_CDS_RETURN;
  
!   static void verify() NOT_CDS_RETURN;
  
    // Widget for recording dependencies, as an N-to-M graph relation,
    // possibly cyclic.
    template<typename E>
    class DepList : public StackObj {
+     static const int INITIAL_CAPACITY = 10;
+ 
      GrowableArrayCHeap<E, mtCompiler>* _deps_dyn;
      Array<E>*                          _deps;
+ 
+     void copy_on_write_if_necessary() {
+       TrainingDataLocker::assert_locked_or_snapshotted();
+       if (_deps != nullptr && _deps_dyn == nullptr) {
+         _deps_dyn = new GrowableArrayCHeap<E, mtCompiler>(length() + INITIAL_CAPACITY);
+         for (int i = 0; _deps->length(); i++) {
+           _deps_dyn->append(_deps->at(i));
+         }
+         _deps = nullptr;
+       }
+     }
    public:
      DepList() {
        _deps_dyn = nullptr;
        _deps = nullptr;
      }

*** 347,48 ***
        TrainingDataLocker::assert_locked_or_snapshotted();
        return (_deps_dyn != nullptr ? _deps_dyn->length()
                : _deps   != nullptr ? _deps->length()
                : 0);
      }
-     E* adr_at(int i) const {
-       TrainingDataLocker::assert_locked_or_snapshotted();
-       return (_deps_dyn != nullptr ? _deps_dyn->adr_at(i)
-               : _deps   != nullptr ? _deps->adr_at(i)
-               : nullptr);
-     }
      E at(int i) const {
        TrainingDataLocker::assert_locked_or_snapshotted();
        assert(i >= 0 && i < length(), "oob");
!       return *adr_at(i);
      }
      bool append_if_missing(E dep) {
        TrainingDataLocker::assert_can_add();
        if (_deps_dyn == nullptr) {
!         _deps_dyn = new GrowableArrayCHeap<E, mtCompiler>(10);
          _deps_dyn->append(dep);
          return true;
        } else {
          return _deps_dyn->append_if_missing(dep);
        }
      }
      bool remove_if_existing(E dep) {
        TrainingDataLocker::assert_can_add();
        if (_deps_dyn != nullptr) {
          return _deps_dyn->remove_if_existing(dep);
        }
        return false;
      }
      void clear() {
        TrainingDataLocker::assert_can_add();
        if (_deps_dyn != nullptr)  {
          _deps_dyn->clear();
        }
      }
      void append(E dep) {
        TrainingDataLocker::assert_can_add();
        if (_deps_dyn == nullptr) {
!         _deps_dyn = new GrowableArrayCHeap<E, mtCompiler>(10);
        }
        _deps_dyn->append(dep);
      }
      bool contains(E dep) {
        TrainingDataLocker::assert_locked();
--- 361,50 ---
        TrainingDataLocker::assert_locked_or_snapshotted();
        return (_deps_dyn != nullptr ? _deps_dyn->length()
                : _deps   != nullptr ? _deps->length()
                : 0);
      }
      E at(int i) const {
        TrainingDataLocker::assert_locked_or_snapshotted();
        assert(i >= 0 && i < length(), "oob");
!       if (_deps_dyn != nullptr) {
+         return _deps_dyn->at(i);
+       } else if (_deps != nullptr) {
+         return _deps->at(i);
+       } else ShouldNotReachHere();
      }
      bool append_if_missing(E dep) {
        TrainingDataLocker::assert_can_add();
+       copy_on_write_if_necessary();
        if (_deps_dyn == nullptr) {
!         _deps_dyn = new GrowableArrayCHeap<E, mtCompiler>(INITIAL_CAPACITY);
          _deps_dyn->append(dep);
          return true;
        } else {
          return _deps_dyn->append_if_missing(dep);
        }
      }
      bool remove_if_existing(E dep) {
        TrainingDataLocker::assert_can_add();
+       copy_on_write_if_necessary();
        if (_deps_dyn != nullptr) {
          return _deps_dyn->remove_if_existing(dep);
        }
        return false;
      }
      void clear() {
        TrainingDataLocker::assert_can_add();
        if (_deps_dyn != nullptr)  {
          _deps_dyn->clear();
        }
+       _deps = nullptr;
      }
      void append(E dep) {
        TrainingDataLocker::assert_can_add();
+       copy_on_write_if_necessary();
        if (_deps_dyn == nullptr) {
!         _deps_dyn = new GrowableArrayCHeap<E, mtCompiler>(INITIAL_CAPACITY);
        }
        _deps_dyn->append(dep);
      }
      bool contains(E dep) {
        TrainingDataLocker::assert_locked();

*** 766,17 ***
--- 782,23 ---
    }
  
    static int level_mask(int level) {
      return ((level & 0xF) != level ? 0 : 1 << level);
    }
+   static CompLevel highest_level(int mask) {
+     if (mask == 0)  return (CompLevel) 0;
+     int diff = (count_leading_zeros(level_mask(0)) - count_leading_zeros(mask));
+     return (CompLevel) diff;
+   }
  
   public:
    KlassTrainingData* klass()  const { return _klass; }
    bool has_holder()           const { return _holder != nullptr; }
    Method* holder()            const { return _holder; }
    bool only_inlined()         const { return !_was_toplevel; }
    bool saw_level(CompLevel l) const { return (_level_mask & level_mask(l)) != 0; }
+   int highest_level()         const { return highest_level(_level_mask); }
    int highest_top_level()     const { return _highest_top_level; }
    MethodData* final_profile() const { return _final_profile; }
    int invocation_count() const { return _invocation_count; }
    int backedge_count() const { return _backedge_count; }