jdk8-mips64-public/hotspot: src/share/vm/runtime/fprofiler.hpp@eef07cd490d4 (annotated)

src/share/vm/runtime/fprofiler.hpp@eef07cd490d4 (annotated)

src/share/vm/runtime/fprofiler.hpp

Wed, 03 Jul 2019 20:42:37 +0800

author: aoqi
date: Wed, 03 Jul 2019 20:42:37 +0800
changeset 9637: eef07cd490d4
parent 6876: 710a3c8b516e
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #ifndef SHARE_VM_RUNTIME_FPROFILER_HPP
 #define SHARE_VM_RUNTIME_FPROFILER_HPP
 #include "utilities/macros.hpp"
 #include "runtime/timer.hpp"
 // a simple flat profiler for Java
 // Forward declaration of classes defined in this header file
 class ThreadProfiler;
 class ThreadProfilerMark;
 class FlatProfiler;
 class IntervalData;
 // Declarations of classes defined only in the implementation.
 class ProfilerNode;
 class FlatProfilerTask;
 enum TickPosition {
   tp_code,
   tp_native
 };
 // One of these guys is constructed as we enter interesting regions
 // and destructed as we exit the region.  While we are in the region
 // ticks are allotted to the region.
 class ThreadProfilerMark: public StackObj {
 public:
   // For now, the only thread-specific region is the class loader.
   enum Region { noRegion, classLoaderRegion, extraRegion, maxRegion };
   ThreadProfilerMark(Region)  NOT_FPROF_RETURN;
   ~ThreadProfilerMark()       NOT_FPROF_RETURN;
 private:
   ThreadProfiler* _pp;
   Region _r;
 };
 #if INCLUDE_FPROF
 class IntervalData VALUE_OBJ_CLASS_SPEC {
   // Just to keep these things all together
 private:
   int _interpreted;
   int _compiled;
   int _native;
   int _compiling;
 public:
   int interpreted() {
     return _interpreted;
   }
   int compiled() {
     return _compiled;
   }
   int native() {
     return _native;
   }
   int compiling() {
     return _compiling;
   }
   int total() {
     return (interpreted() + compiled() + native() + compiling());
   }
   void inc_interpreted() {
     _interpreted += 1;
   }
   void inc_compiled() {
     _compiled += 1;
   }
   void inc_native() {
     _native += 1;
   }
   void inc_compiling() {
     _compiling += 1;
   }
   void reset() {
     _interpreted = 0;
     _compiled = 0;
     _native = 0;
     _compiling = 0;
   }
   static void print_header(outputStream* st);
   void print_data(outputStream* st);
 };
 #endif // INCLUDE_FPROF
 class ThreadProfiler: public CHeapObj<mtInternal> {
 public:
   ThreadProfiler()    NOT_FPROF_RETURN;
   ~ThreadProfiler()   NOT_FPROF_RETURN;
   // Resets the profiler
   void reset()        NOT_FPROF_RETURN;
   // Activates the profiler for a certain thread
   void engage()       NOT_FPROF_RETURN;
   // Deactivates the profiler
   void disengage()    NOT_FPROF_RETURN;
   // Prints the collected profiling information
   void print(const char* thread_name) NOT_FPROF_RETURN;
   // Garbage Collection Support
   void oops_do(OopClosure* f)         NOT_FPROF_RETURN;
 #if INCLUDE_FPROF
 private:
   // for recording ticks.
   friend class ProfilerNode;
   char* area_bottom; // preallocated area for pnodes
   char* area_top;
   char* area_limit;
   static int            table_size;
   ProfilerNode** table;
 private:
   void record_interpreted_tick(JavaThread* thread, frame fr, TickPosition where, int* ticks);
   void record_compiled_tick   (JavaThread* thread, frame fr, TickPosition where);
   void interpreted_update(Method* method, TickPosition where);
   void compiled_update   (Method* method, TickPosition where);
   void stub_update       (Method* method, const char* name, TickPosition where);
   void adapter_update    (TickPosition where);
   void runtime_stub_update(const CodeBlob* stub, const char* name, TickPosition where);
   void unknown_compiled_update    (const CodeBlob* cb, TickPosition where);
   void vm_update    (TickPosition where);
   void vm_update    (const char* name, TickPosition where);
   void record_tick_for_running_frame(JavaThread* thread, frame fr);
   void record_tick_for_calling_frame(JavaThread* thread, frame fr);
   void initialize();
   static int  entry(int value);
 private:
   friend class FlatProfiler;
   void record_tick(JavaThread* thread);
   bool engaged;
   // so we can do percentages for this thread, and quick checks for activity
   int thread_ticks;
   int compiler_ticks;
   int interpreter_ticks;
 public:
   void inc_thread_ticks() { thread_ticks += 1; }
 private:
   friend class ThreadProfilerMark;
   // counters for thread-specific regions
   bool region_flag[ThreadProfilerMark::maxRegion];
   int class_loader_ticks;
   int extra_ticks;
 private:
   // other thread-specific regions
   int blocked_ticks;
   enum UnknownTickSites {
       ut_null_method,
       ut_vtable_stubs,
       ut_running_frame,
       ut_calling_frame,
       ut_no_pc,
       ut_no_last_Java_frame,
       ut_unknown_thread_state,
       ut_end
   };
   int unknown_ticks_array[ut_end];
   int unknown_ticks() {
     int result = 0;
     for (int ut = 0; ut < ut_end; ut += 1) {
       result += unknown_ticks_array[ut];
     }
     return result;
   }
   elapsedTimer timer;
   // For interval timing
 private:
   IntervalData _interval_data;
   IntervalData interval_data() {
     return _interval_data;
   }
   IntervalData* interval_data_ref() {
     return &_interval_data;
   }
 #endif // INCLUDE_FPROF
 };
 class FlatProfiler: AllStatic {
 public:
   static void reset() NOT_FPROF_RETURN ;
   static void engage(JavaThread* mainThread, bool fullProfile) NOT_FPROF_RETURN ;
   static void disengage() NOT_FPROF_RETURN ;
   static void print(int unused) NOT_FPROF_RETURN ;
   static bool is_active() NOT_FPROF_RETURN_(false) ;
   // This is NULL if each thread has its own thread profiler,
   // else this is the single thread profiler used by all threads.
   // In particular it makes a difference during garbage collection,
   // where you only want to traverse each thread profiler once.
   static ThreadProfiler* get_thread_profiler() NOT_FPROF_RETURN_(NULL);
   // Garbage Collection Support
   static void oops_do(OopClosure* f) NOT_FPROF_RETURN ;
   // Support for disassembler to inspect the PCRecorder
   // Returns the start address for a given pc
   // NULL is returned if the PCRecorder is inactive
   static address bucket_start_for(address pc) NOT_FPROF_RETURN_(NULL);
   enum { MillisecsPerTick = 10 };   // ms per profiling ticks
   // Returns the number of ticks recorded for the bucket
   // pc belongs to.
   static int bucket_count_for(address pc) NOT_FPROF_RETURN_(0);
 #if INCLUDE_FPROF
  private:
   static bool full_profile() {
     return full_profile_flag;
   }
   friend class ThreadProfiler;
   // the following group of ticks cover everything that's not attributed to individual Java methods
   static int  received_gc_ticks;      // ticks during which gc was active
   static int vm_operation_ticks;      // total ticks in vm_operations other than GC
   static int threads_lock_ticks;      // the number of times we couldn't get the Threads_lock without blocking
   static int      blocked_ticks;      // ticks when the thread was blocked.
   static int class_loader_ticks;      // total ticks in class loader
   static int        extra_ticks;      // total ticks an extra temporary measuring
   static int     compiler_ticks;      // total ticks in compilation
   static int  interpreter_ticks;      // ticks in unknown interpreted method
   static int        deopt_ticks;      // ticks in deoptimization
   static int      unknown_ticks;      // ticks that cannot be categorized
   static int     received_ticks;      // ticks that were received by task
   static int    delivered_ticks;      // ticks that were delivered by task
   static int non_method_ticks() {
     return
       ( received_gc_ticks
       + vm_operation_ticks
       + deopt_ticks
       + threads_lock_ticks
       + blocked_ticks
       + compiler_ticks
       + interpreter_ticks
       + unknown_ticks );
   }
   static elapsedTimer timer;
   // Counts of each of the byte codes
   static int*           bytecode_ticks;
   static int*           bytecode_ticks_stub;
   static void print_byte_code_statistics();
   // the ticks below are for continuous profiling (to adjust recompilation, etc.)
   static int          all_ticks;      // total count of ticks received so far
   static int      all_int_ticks;      // ticks in interpreter
   static int     all_comp_ticks;      // ticks in compiled code (+ native)
   static bool full_profile_flag;      // collecting full profile?
   // to accumulate thread-specific data
   // if we aren't profiling individual threads.
   static ThreadProfiler* thread_profiler;
   static ThreadProfiler* vm_thread_profiler;
   static void allocate_table();
   // The task that periodically interrupts things.
   friend class FlatProfilerTask;
   static FlatProfilerTask* task;
   static void record_vm_operation();
   static void record_vm_tick();
   static void record_thread_ticks();
   // For interval analysis
  private:
   static int interval_ticks_previous;  // delivered_ticks from the last interval
   static void interval_record_thread(ThreadProfiler* tp); // extract ticks from ThreadProfiler.
   static void interval_print();       // print interval data.
   static void interval_reset();       // reset interval data.
   enum {interval_print_size = 10};
   static IntervalData* interval_data;
 #endif // INCLUDE_FPROF
 };
 #endif // SHARE_VM_RUNTIME_FPROFILER_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/runtime/fprofiler.hpp@eef07cd490d4 (annotated)

src/share/vm/runtime/fprofiler.hpp