1 /*
  2  * Copyright (c) 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 #include "precompiled.hpp"
 26 #include "cds/methodProfiler.hpp"
 27 #include "code/codeBlob.hpp"
 28 #include "code/nmethod.hpp"
 29 #include "logging/log.hpp"
 30 #include "runtime/frame.inline.hpp"
 31 #include "runtime/handshake.hpp"
 32 #include "runtime/javaThread.hpp"
 33 #include "runtime/registerMap.hpp"
 34 #include "runtime/task.hpp"
 35 
 36 volatile uint64_t MethodProfiler::_num_samples = 0;
 37 class MethodProfilerTask : public PeriodicTask {
 38 public:
 39   MethodProfilerTask()
 40     : PeriodicTask(RecordOptCompilationOrderInterval) {}
 41 
 42   void task() {
 43     MethodProfiler::tick();
 44   }
 45 };
 46 
 47 static MethodProfilerTask* _task;
 48 
 49 void MethodProfiler::initialize() {
 50   if (RecordOptCompilationOrder) {
 51     _task = new MethodProfilerTask();
 52     _task->enroll();
 53   }
 54 }
 55 
 56 class MethodProfilerClosure : public HandshakeClosure {
 57 public:
 58 MethodProfilerClosure()
 59     : HandshakeClosure("MethodProfiler") {}
 60 
 61   void do_thread(Thread* thread) {
 62     ResourceMark rm;
 63 
 64     if (thread != Thread::current()) {
 65       // Run by the VM thread - implication is that the target
 66       // thread was blocked or in native, i.e. not executing
 67       // Java code.
 68       return;
 69     }
 70 
 71     JavaThread* jt = JavaThread::cast(thread);
 72     if (!jt->has_last_Java_frame()) {
 73       return;
 74     }
 75 
 76     frame fr = jt->last_frame();
 77     if (fr.is_safepoint_blob_frame()) {
 78       RegisterMap rm(jt,
 79                      RegisterMap::UpdateMap::skip,
 80                      RegisterMap::ProcessFrames::skip,
 81                      RegisterMap::WalkContinuation::skip);
 82       fr = fr.sender(&rm);
 83     }
 84 
 85     if (!fr.is_compiled_frame()) {
 86       return;
 87     }
 88 
 89     nmethod* nm = fr.cb()->as_nmethod();
 90     if (!nm->is_compiled_by_c2()) {
 91       return;
 92     }
 93 
 94     log_trace(cds, profiling)("%s sampled %s::%s: " UINT64_FORMAT,
 95                               thread->name(),
 96                               nm->method()->method_holder()->name()->as_C_string(),
 97                               nm->method()->name()->as_C_string(),
 98                               nm->method_profiling_count());
 99 
100     // Found a C2 top frame that was just executing - sample it
101     nm->inc_method_profiling_count();
102     Atomic::inc(&MethodProfiler::_num_samples);
103   }
104 };
105 
106 void MethodProfiler::tick() {
107   MethodProfilerClosure cl;
108   Handshake::execute(&cl);
109 }
110 
111 static int method_hotness_compare(nmethod** a, nmethod** b) {
112   return (*b)->method_profiling_count() - (*a)->method_profiling_count();
113 }
114 
115 
116 GrowableArrayCHeap<nmethod*, mtClassShared>* MethodProfiler::sampled_nmethods() {
117   GrowableArrayCHeap<nmethod*, mtClassShared>* nmethods = new GrowableArrayCHeap<nmethod*, mtClassShared>();
118 
119   {
120     MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
121     NMethodIterator iter(NMethodIterator::only_not_unloading);
122     while(iter.next()) {
123       nmethod* nm = iter.method();
124       if (nm->is_compiled_by_c2() || nm->is_compiled_by_jvmci()) {
125         nmethods->append(nm);
126       }
127     }
128   }
129 
130   nmethods->sort(&method_hotness_compare);
131 
132   return nmethods;
133 }
134 
135 double MethodProfiler::hotness(nmethod* nm) {
136   return double(nm->method_profiling_count()) / double(_num_samples) * 100.0;
137 }
138 
139 uint64_t MethodProfiler::num_samples() {
140   return _num_samples;
141 }
142 
143 void MethodProfiler::process_method_hotness() {
144   if (_num_samples == 0) {
145     return;
146   }
147 
148   _task->disenroll();
149 
150   LogTarget(Debug, cds, profiling) lt;
151   if (lt.is_enabled()) {
152     ResourceMark rm;
153     double accumulated_sample_percent = 0.0;
154     int i = 0;
155     GrowableArrayCHeap<nmethod*, mtClassShared>* nmethods = sampled_nmethods();
156 
157     for (auto it = nmethods->begin(); it != nmethods->end(); ++it) {
158       ++i;
159       nmethod* nm = *it;
160       if (nm->method_profiling_count() == 0) {
161         break;
162       }
163       double sample_percent = hotness(nm);
164       accumulated_sample_percent += sample_percent;
165       log_info(cds, profiling)("%d (%.2f). %s::%s: " UINT64_FORMAT " (%.2f%%, %.2f%% accumulated)",
166                                i,
167                                double(i) / double(nmethods->length()) * 100.0,
168                                nm->method()->method_holder()->name()->as_C_string(),
169                                nm->method()->name()->as_C_string(),
170                                nm->method_profiling_count(),
171                                sample_percent,
172                                accumulated_sample_percent);
173     }
174 
175     delete nmethods;
176   }
177 }