1 /*

     2  * Copyright (c) 2013, 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_VM_OOPS_METHODCOUNTERS_HPP

    26 #define SHARE_VM_OOPS_METHODCOUNTERS_HPP

    27 

    28 #include "oops/metadata.hpp"

    29 #include "interpreter/invocationCounter.hpp"

    30 

    31 class MethodCounters: public MetaspaceObj {

    32  friend class VMStructs;

    33  private:

    34   int               _interpreter_invocation_count; // Count of times invoked (reused as prev_event_count in tiered)

    35   u2                _interpreter_throwout_count; // Count of times method was exited via exception while interpreting

    36   u2                _number_of_breakpoints;      // fullspeed debugging support

    37   InvocationCounter _invocation_counter;         // Incremented before each activation of the method - used to trigger frequency-based optimizations

    38   InvocationCounter _backedge_counter;           // Incremented before each backedge taken - used to trigger frequencey-based optimizations

    39 

    40 #ifdef TIERED

    41   float             _rate;                        // Events (invocation and backedge counter increments) per millisecond

    42   jlong             _prev_time;                   // Previous time the rate was acquired

    43 #endif

    44 

    45   MethodCounters() : _interpreter_invocation_count(0),

    46                      _interpreter_throwout_count(0),

    47                      _number_of_breakpoints(0)

    48 #ifdef TIERED

    49                    , _rate(0),

    50                      _prev_time(0)

    51 #endif

    52   {

    53     invocation_counter()->init();

    54     backedge_counter()->init();

    55   }

    56 

    57  public:

    58   static MethodCounters* allocate(ClassLoaderData* loader_data, TRAPS);

    59 

    60   void deallocate_contents(ClassLoaderData* loader_data) {}

    61   DEBUG_ONLY(bool on_stack() { return false; })  // for template

    62 

    63   static int size() { return sizeof(MethodCounters) / wordSize; }

    64 

    65   bool is_klass() const { return false; }

    66 

    67   void clear_counters();

    68 

    69   int interpreter_invocation_count() {

    70     return _interpreter_invocation_count;

    71   }

    72   void set_interpreter_invocation_count(int count) {

    73     _interpreter_invocation_count = count;

    74   }

    75   int increment_interpreter_invocation_count() {

    76     return ++_interpreter_invocation_count;

    77   }

    78 

    79   void interpreter_throwout_increment() {

    80     if (_interpreter_throwout_count < 65534) {

    81       _interpreter_throwout_count++;

    82     }

    83   }

    84   int  interpreter_throwout_count() const {

    85     return _interpreter_throwout_count;

    86   }

    87   void set_interpreter_throwout_count(int count) {

    88     _interpreter_throwout_count = count;

    89   }

    90 

    91   u2   number_of_breakpoints() const   { return _number_of_breakpoints; }

    92   void incr_number_of_breakpoints()    { ++_number_of_breakpoints; }

    93   void decr_number_of_breakpoints()    { --_number_of_breakpoints; }

    94   void clear_number_of_breakpoints()   { _number_of_breakpoints = 0; }

    95 

    96 #ifdef TIERED

    97   jlong prev_time() const                        { return _prev_time; }

    98   void set_prev_time(jlong time)                 { _prev_time = time; }

    99   float rate() const                             { return _rate; }

   100   void set_rate(float rate)                      { _rate = rate; }

   101 #endif

   102 

   103   // invocation counter

   104   InvocationCounter* invocation_counter() { return &_invocation_counter; }

   105   InvocationCounter* backedge_counter()   { return &_backedge_counter; }

   106 

   107   static ByteSize interpreter_invocation_counter_offset() {

   108     return byte_offset_of(MethodCounters, _interpreter_invocation_count);

   109   }

   110 

   111   static ByteSize invocation_counter_offset()    {

   112     return byte_offset_of(MethodCounters, _invocation_counter);

   113   }

   114 

   115   static ByteSize backedge_counter_offset()      {

   116     return byte_offset_of(MethodCounters, _backedge_counter);

   117   }

   118 

   119   static int interpreter_invocation_counter_offset_in_bytes() {

   120     return offset_of(MethodCounters, _interpreter_invocation_count);

   121   }

   122 

   123 };

   124 #endif //SHARE_VM_OOPS_METHODCOUNTERS_HPP