1 /*
  2  * Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_OOPS_METHODCOUNTERS_HPP
 26 #define SHARE_OOPS_METHODCOUNTERS_HPP
 27 
 28 #include "oops/metadata.hpp"
 29 #include "compiler/compilerDefinitions.hpp"
 30 #include "compiler/compilerOracle.hpp"
 31 #include "interpreter/invocationCounter.hpp"
 32 #include "utilities/align.hpp"
 33 
 34 class MethodCounters : public Metadata {
 35  friend class VMStructs;
 36  friend class JVMCIVMStructs;
 37  private:
 38   InvocationCounter _invocation_counter;         // Incremented before each activation of the method - used to trigger frequency-based optimizations
 39   InvocationCounter _backedge_counter;           // Incremented before each backedge taken - used to trigger frequency-based optimizations
 40   jlong             _prev_time;                   // Previous time the rate was acquired
 41   float             _rate;                        // Events (invocation and backedge counter increments) per millisecond
 42   int               _invoke_mask;                 // per-method Tier0InvokeNotifyFreqLog
 43   int               _backedge_mask;               // per-method Tier0BackedgeNotifyFreqLog
 44   int               _prev_event_count;            // Total number of events saved at previous callback
 45 #if COMPILER2_OR_JVMCI
 46   u2                _interpreter_throwout_count; // Count of times method was exited via exception while interpreting
 47 #endif
 48 #if INCLUDE_JVMTI
 49   u2                _number_of_breakpoints;      // fullspeed debugging support
 50 #endif
 51   u1                _highest_comp_level;          // Highest compile level this method has ever seen.
 52   u1                _highest_osr_comp_level;      // Same for OSR level
 53 
 54   MethodCounters(const methodHandle& mh);
 55  public:
 56   virtual bool is_methodCounters() const { return true; }
 57 
 58   static MethodCounters* allocate_no_exception(const methodHandle& mh);
 59   static MethodCounters* allocate_with_exception(const methodHandle& mh, TRAPS);
 60 
 61   void deallocate_contents(ClassLoaderData* loader_data) {}
 62 
 63   static int method_counters_size() {
 64     return align_up((int)sizeof(MethodCounters), wordSize) / wordSize;
 65   }
 66   virtual int size() const {
 67     return method_counters_size();
 68   }
 69   MetaspaceObj::Type type() const { return MethodCountersType; }
 70   void clear_counters();
 71 
 72 #if COMPILER2_OR_JVMCI
 73   void interpreter_throwout_increment() {
 74     if (_interpreter_throwout_count < 65534) {
 75       _interpreter_throwout_count++;
 76     }
 77   }
 78   u2  interpreter_throwout_count() const {
 79     return _interpreter_throwout_count;
 80   }
 81   void set_interpreter_throwout_count(u2 count) {
 82     _interpreter_throwout_count = count;
 83   }
 84 #else // COMPILER2_OR_JVMCI
 85   u2  interpreter_throwout_count() const {
 86     return 0;
 87   }
 88   void set_interpreter_throwout_count(u2 count) {
 89     assert(count == 0, "count must be 0");
 90   }
 91 #endif // COMPILER2_OR_JVMCI
 92 
 93 #if INCLUDE_JVMTI
 94   u2   number_of_breakpoints() const   { return _number_of_breakpoints; }
 95   void incr_number_of_breakpoints()    { ++_number_of_breakpoints; }
 96   void decr_number_of_breakpoints()    { --_number_of_breakpoints; }
 97   void clear_number_of_breakpoints()   { _number_of_breakpoints = 0; }
 98 #endif
 99 
100   int prev_event_count() const                   { return _prev_event_count;  }
101   void set_prev_event_count(int count)           { _prev_event_count = count; }
102   jlong prev_time() const                        { return _prev_time; }
103   void set_prev_time(jlong time)                 { _prev_time = time; }
104   float rate() const                             { return _rate; }
105   void set_rate(float rate)                      { _rate = rate; }
106 
107   int highest_comp_level() const                 { return _highest_comp_level;  }
108   void set_highest_comp_level(int level)         { _highest_comp_level = (u1)level; }
109   int highest_osr_comp_level() const             { return _highest_osr_comp_level;  }
110   void set_highest_osr_comp_level(int level)     { _highest_osr_comp_level = (u1)level; }
111 
112   // invocation counter
113   InvocationCounter* invocation_counter() { return &_invocation_counter; }
114   InvocationCounter* backedge_counter()   { return &_backedge_counter; }
115 
116   static ByteSize invocation_counter_offset()    {
117     return byte_offset_of(MethodCounters, _invocation_counter);
118   }
119 
120   static ByteSize backedge_counter_offset()      {
121     return byte_offset_of(MethodCounters, _backedge_counter);
122   }
123 
124   static ByteSize invoke_mask_offset() {
125     return byte_offset_of(MethodCounters, _invoke_mask);
126   }
127 
128   static ByteSize backedge_mask_offset() {
129     return byte_offset_of(MethodCounters, _backedge_mask);
130   }
131 
132   virtual const char* internal_name() const { return "{method counters}"; }
133   virtual void print_value_on(outputStream* st) const;
134 
135 };
136 #endif // SHARE_OOPS_METHODCOUNTERS_HPP