src/share/vm/code/nmethod.hpp

*** 117,127 ****
    jmethodID _jmethod_id;       // Cache of method()->jmethod_id()
  
    // To support simple linked-list chaining of nmethods:
    nmethod*  _osr_link;         // from InstanceKlass::osr_nmethods_head
    nmethod*  _scavenge_root_link; // from CodeCache::scavenge_root_nmethods
-   nmethod*  _saved_nmethod_link; // from CodeCache::speculatively_disconnect
  
    static nmethod* volatile _oops_do_mark_nmethods;
    nmethod*        volatile _oops_do_mark_link;
  
    AbstractCompiler* _compiler; // The compiler which compiled this nmethod
--- 117,126 ----
*** 163,173 ****
    int _compile_id;                           // which compilation made this nmethod
    int _comp_level;                           // compilation level
  
    // protected by CodeCache_lock
    bool _has_flushed_dependencies;            // Used for maintenance of dependencies (CodeCache_lock)
-   bool _speculatively_disconnected;          // Marked for potential unload
  
    bool _marked_for_reclamation;              // Used by NMethodSweeper (set only by sweeper)
    bool _marked_for_deoptimization;           // Used for stack deoptimization
  
    // used by jvmti to track if an unload event has been posted for this nmethod.
--- 162,171 ----
*** 200,214 ****
    // event processing needs to be done.
    jint  _lock_count;
  
    // not_entrant method removal. Each mark_sweep pass will update
    // this mark to current sweep invocation count if it is seen on the
!   // stack.  An not_entrant method can be removed when there is no
    // more activations, i.e., when the _stack_traversal_mark is less than
    // current sweep traversal index.
    long _stack_traversal_mark;
  
    ExceptionCache *_exception_cache;
    PcDescCache     _pc_desc_cache;
  
    // These are used for compiled synchronized native methods to
    // locate the owner and stack slot for the BasicLock so that we can
--- 198,219 ----
    // event processing needs to be done.
    jint  _lock_count;
  
    // not_entrant method removal. Each mark_sweep pass will update
    // this mark to current sweep invocation count if it is seen on the
!   // stack.  An not_entrant method can be removed when there are no
    // more activations, i.e., when the _stack_traversal_mark is less than
    // current sweep traversal index.
    long _stack_traversal_mark;
  
+   // The _hotness_counter indicates the hotness of a method. The higher
+   // the value the hotter the method. The hotness counter of a nmethod is
+   // set to [(ReservedCodeCacheSize / (1024 * 1024)) * 2] each time the method
+   // is active while stack scanning (mark_active_nmethods()). The hotness
+   // counter is decreased (by 1) while sweeping.
+   int _hotness_counter;
+ 
    ExceptionCache *_exception_cache;
    PcDescCache     _pc_desc_cache;
  
    // These are used for compiled synchronized native methods to
    // locate the owner and stack slot for the BasicLock so that we can
*** 380,389 ****
--- 385,398 ----
    int handler_table_size() const                  { return            handler_table_end() -            handler_table_begin(); }
    int nul_chk_table_size() const                  { return            nul_chk_table_end() -            nul_chk_table_begin(); }
  
    int total_size        () const;
  
+   void dec_hotness_counter()        { _hotness_counter--; }
+   void set_hotness_counter(int val) { _hotness_counter = val; }
+   int  hotness_counter() const      { return _hotness_counter; }
+ 
    // Containment
    bool consts_contains       (address addr) const { return consts_begin       () <= addr && addr < consts_end       (); }
    bool insts_contains        (address addr) const { return insts_begin        () <= addr && addr < insts_end        (); }
    bool stub_contains         (address addr) const { return stub_begin         () <= addr && addr < stub_end         (); }
    bool oops_contains         (oop*    addr) const { return oops_begin         () <= addr && addr < oops_end         (); }
*** 435,447 ****
    void  set_has_unsafe_access(bool z)             { _has_unsafe_access = z; }
  
    bool  has_method_handle_invokes() const         { return _has_method_handle_invokes; }
    void  set_has_method_handle_invokes(bool z)     { _has_method_handle_invokes = z; }
  
-   bool  is_speculatively_disconnected() const     { return _speculatively_disconnected; }
-   void  set_speculatively_disconnected(bool z)    { _speculatively_disconnected = z; }
- 
    bool  is_lazy_critical_native() const           { return _lazy_critical_native; }
    void  set_lazy_critical_native(bool z)          { _lazy_critical_native = z; }
  
    bool  has_wide_vectors() const                  { return _has_wide_vectors; }
    void  set_has_wide_vectors(bool z)              { _has_wide_vectors = z; }
--- 444,453 ----
*** 497,509 ****
    // N.B. there is no positive marked query, and we only use the not_marked query for asserts.
  #endif //PRODUCT
    nmethod* scavenge_root_link() const                  { return _scavenge_root_link; }
    void     set_scavenge_root_link(nmethod *n)          { _scavenge_root_link = n; }
  
-   nmethod* saved_nmethod_link() const                  { return _saved_nmethod_link; }
-   void     set_saved_nmethod_link(nmethod *n)          { _saved_nmethod_link = n; }
- 
   public:
  
    // Sweeper support
    long  stack_traversal_mark()                    { return _stack_traversal_mark; }
    void  set_stack_traversal_mark(long l)          { _stack_traversal_mark = l; }
--- 503,512 ----