171
172 // Timers and counters for generating statistics
173 elapsedTimer CompileBroker::_t_total_compilation;
174 elapsedTimer CompileBroker::_t_osr_compilation;
175 elapsedTimer CompileBroker::_t_standard_compilation;
176 elapsedTimer CompileBroker::_t_invalidated_compilation;
177 elapsedTimer CompileBroker::_t_bailedout_compilation;
178
179 uint CompileBroker::_total_bailout_count = 0;
180 uint CompileBroker::_total_invalidated_count = 0;
181 uint CompileBroker::_total_compile_count = 0;
182 uint CompileBroker::_total_osr_compile_count = 0;
183 uint CompileBroker::_total_standard_compile_count = 0;
184 uint CompileBroker::_total_compiler_stopped_count = 0;
185 uint CompileBroker::_total_compiler_restarted_count = 0;
186
187 uint CompileBroker::_sum_osr_bytes_compiled = 0;
188 uint CompileBroker::_sum_standard_bytes_compiled = 0;
189 uint CompileBroker::_sum_nmethod_size = 0;
190 uint CompileBroker::_sum_nmethod_code_size = 0;
191
192 jlong CompileBroker::_peak_compilation_time = 0;
193
194 CompilerStatistics CompileBroker::_stats_per_level[CompLevel_full_optimization];
195
196 CompileQueue* CompileBroker::_c2_compile_queue = nullptr;
197 CompileQueue* CompileBroker::_c1_compile_queue = nullptr;
198
199 bool compileBroker_init() {
200 if (LogEvents) {
201 CompilationLog::init();
202 }
203
204 // init directives stack, adding default directive
205 DirectivesStack::init();
206
207 if (DirectivesParser::has_file()) {
208 return DirectivesParser::parse_from_flag();
209 } else if (CompilerDirectivesPrint) {
210 // Print default directive even when no other was added
2637 task->num_inlined_bytecodes());
2638 if (is_osr) {
2639 _perf_osr_compilation->inc(time.ticks());
2640 _perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
2641 } else {
2642 _perf_standard_compilation->inc(time.ticks());
2643 _perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
2644 }
2645 }
2646
2647 if (CITimeEach) {
2648 double compile_time = time.seconds();
2649 double bytes_per_sec = compile_time == 0.0 ? 0.0 : (double)(method->code_size() + task->num_inlined_bytecodes()) / compile_time;
2650 tty->print_cr("%3d seconds: %6.3f bytes/sec : %f (bytes %d + %d inlined)",
2651 compile_id, compile_time, bytes_per_sec, method->code_size(), task->num_inlined_bytecodes());
2652 }
2653
2654 // Collect counts of successful compilations
2655 _sum_nmethod_size += task->nm_total_size();
2656 _sum_nmethod_code_size += task->nm_insts_size();
2657 _total_compile_count++;
2658
2659 if (UsePerfData) {
2660 _perf_sum_nmethod_size->inc( task->nm_total_size());
2661 _perf_sum_nmethod_code_size->inc(task->nm_insts_size());
2662 _perf_total_compile_count->inc();
2663 }
2664
2665 if (is_osr) {
2666 if (UsePerfData) _perf_total_osr_compile_count->inc();
2667 _total_osr_compile_count++;
2668 } else {
2669 if (UsePerfData) _perf_total_standard_compile_count->inc();
2670 _total_standard_compile_count++;
2671 }
2672 }
2673 // set the current method for the thread to null
2674 if (UsePerfData) counters->set_current_method("");
2675 }
2676
2724 }
2725
2726 if (!aggregate) {
2727 return;
2728 }
2729
2730 elapsedTimer standard_compilation = CompileBroker::_t_standard_compilation;
2731 elapsedTimer osr_compilation = CompileBroker::_t_osr_compilation;
2732 elapsedTimer total_compilation = CompileBroker::_t_total_compilation;
2733
2734 uint standard_bytes_compiled = CompileBroker::_sum_standard_bytes_compiled;
2735 uint osr_bytes_compiled = CompileBroker::_sum_osr_bytes_compiled;
2736
2737 uint standard_compile_count = CompileBroker::_total_standard_compile_count;
2738 uint osr_compile_count = CompileBroker::_total_osr_compile_count;
2739 uint total_compile_count = CompileBroker::_total_compile_count;
2740 uint total_bailout_count = CompileBroker::_total_bailout_count;
2741 uint total_invalidated_count = CompileBroker::_total_invalidated_count;
2742
2743 uint nmethods_code_size = CompileBroker::_sum_nmethod_code_size;
2744 uint nmethods_size = CompileBroker::_sum_nmethod_size;
2745
2746 tty->cr();
2747 tty->print_cr("Accumulated compiler times");
2748 tty->print_cr("----------------------------------------------------------");
2749 //0000000000111111111122222222223333333333444444444455555555556666666666
2750 //0123456789012345678901234567890123456789012345678901234567890123456789
2751 tty->print_cr(" Total compilation time : %7.3f s", total_compilation.seconds());
2752 tty->print_cr(" Standard compilation : %7.3f s, Average : %2.3f s",
2753 standard_compilation.seconds(),
2754 standard_compile_count == 0 ? 0.0 : standard_compilation.seconds() / standard_compile_count);
2755 tty->print_cr(" Bailed out compilation : %7.3f s, Average : %2.3f s",
2756 CompileBroker::_t_bailedout_compilation.seconds(),
2757 total_bailout_count == 0 ? 0.0 : CompileBroker::_t_bailedout_compilation.seconds() / total_bailout_count);
2758 tty->print_cr(" On stack replacement : %7.3f s, Average : %2.3f s",
2759 osr_compilation.seconds(),
2760 osr_compile_count == 0 ? 0.0 : osr_compilation.seconds() / osr_compile_count);
2761 tty->print_cr(" Invalidated : %7.3f s, Average : %2.3f s",
2762 CompileBroker::_t_invalidated_compilation.seconds(),
2763 total_invalidated_count == 0 ? 0.0 : CompileBroker::_t_invalidated_compilation.seconds() / total_invalidated_count);
2777 JVMCICompiler *jvmci_comp = JVMCICompiler::instance(false, JavaThread::current_or_null());
2778 if (jvmci_comp != nullptr && jvmci_comp != comp) {
2779 tty->cr();
2780 jvmci_comp->print_timers();
2781 }
2782 }
2783 #endif
2784
2785 tty->cr();
2786 tty->print_cr(" Total compiled methods : %8u methods", total_compile_count);
2787 tty->print_cr(" Standard compilation : %8u methods", standard_compile_count);
2788 tty->print_cr(" On stack replacement : %8u methods", osr_compile_count);
2789 uint tcb = osr_bytes_compiled + standard_bytes_compiled;
2790 tty->print_cr(" Total compiled bytecodes : %8u bytes", tcb);
2791 tty->print_cr(" Standard compilation : %8u bytes", standard_bytes_compiled);
2792 tty->print_cr(" On stack replacement : %8u bytes", osr_bytes_compiled);
2793 double tcs = total_compilation.seconds();
2794 uint bps = tcs == 0.0 ? 0 : (uint)(tcb / tcs);
2795 tty->print_cr(" Average compilation speed : %8u bytes/s", bps);
2796 tty->cr();
2797 tty->print_cr(" nmethod code size : %8u bytes", nmethods_code_size);
2798 tty->print_cr(" nmethod total size : %8u bytes", nmethods_size);
2799 }
2800
2801 // Print general/accumulated JIT information.
2802 void CompileBroker::print_info(outputStream *out) {
2803 if (out == nullptr) out = tty;
2804 out->cr();
2805 out->print_cr("======================");
2806 out->print_cr(" General JIT info ");
2807 out->print_cr("======================");
2808 out->cr();
2809 out->print_cr(" JIT is : %7s", should_compile_new_jobs() ? "on" : "off");
2810 out->print_cr(" Compiler threads : %7d", (int)CICompilerCount);
2811 out->cr();
2812 out->print_cr("CodeCache overview");
2813 out->print_cr("--------------------------------------------------------");
2814 out->cr();
2815 out->print_cr(" Reserved size : %7zu KB", CodeCache::max_capacity() / K);
2816 out->print_cr(" Committed size : %7zu KB", CodeCache::capacity() / K);
|
171
172 // Timers and counters for generating statistics
173 elapsedTimer CompileBroker::_t_total_compilation;
174 elapsedTimer CompileBroker::_t_osr_compilation;
175 elapsedTimer CompileBroker::_t_standard_compilation;
176 elapsedTimer CompileBroker::_t_invalidated_compilation;
177 elapsedTimer CompileBroker::_t_bailedout_compilation;
178
179 uint CompileBroker::_total_bailout_count = 0;
180 uint CompileBroker::_total_invalidated_count = 0;
181 uint CompileBroker::_total_compile_count = 0;
182 uint CompileBroker::_total_osr_compile_count = 0;
183 uint CompileBroker::_total_standard_compile_count = 0;
184 uint CompileBroker::_total_compiler_stopped_count = 0;
185 uint CompileBroker::_total_compiler_restarted_count = 0;
186
187 uint CompileBroker::_sum_osr_bytes_compiled = 0;
188 uint CompileBroker::_sum_standard_bytes_compiled = 0;
189 uint CompileBroker::_sum_nmethod_size = 0;
190 uint CompileBroker::_sum_nmethod_code_size = 0;
191 uint CompileBroker::_largest_nmethod_code_size = 0;
192
193 jlong CompileBroker::_peak_compilation_time = 0;
194
195 CompilerStatistics CompileBroker::_stats_per_level[CompLevel_full_optimization];
196
197 CompileQueue* CompileBroker::_c2_compile_queue = nullptr;
198 CompileQueue* CompileBroker::_c1_compile_queue = nullptr;
199
200 bool compileBroker_init() {
201 if (LogEvents) {
202 CompilationLog::init();
203 }
204
205 // init directives stack, adding default directive
206 DirectivesStack::init();
207
208 if (DirectivesParser::has_file()) {
209 return DirectivesParser::parse_from_flag();
210 } else if (CompilerDirectivesPrint) {
211 // Print default directive even when no other was added
2638 task->num_inlined_bytecodes());
2639 if (is_osr) {
2640 _perf_osr_compilation->inc(time.ticks());
2641 _perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
2642 } else {
2643 _perf_standard_compilation->inc(time.ticks());
2644 _perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
2645 }
2646 }
2647
2648 if (CITimeEach) {
2649 double compile_time = time.seconds();
2650 double bytes_per_sec = compile_time == 0.0 ? 0.0 : (double)(method->code_size() + task->num_inlined_bytecodes()) / compile_time;
2651 tty->print_cr("%3d seconds: %6.3f bytes/sec : %f (bytes %d + %d inlined)",
2652 compile_id, compile_time, bytes_per_sec, method->code_size(), task->num_inlined_bytecodes());
2653 }
2654
2655 // Collect counts of successful compilations
2656 _sum_nmethod_size += task->nm_total_size();
2657 _sum_nmethod_code_size += task->nm_insts_size();
2658 _largest_nmethod_code_size = MAX2(_largest_nmethod_code_size, (uint) task->nm_insts_size());
2659 _total_compile_count++;
2660
2661 if (UsePerfData) {
2662 _perf_sum_nmethod_size->inc( task->nm_total_size());
2663 _perf_sum_nmethod_code_size->inc(task->nm_insts_size());
2664 _perf_total_compile_count->inc();
2665 }
2666
2667 if (is_osr) {
2668 if (UsePerfData) _perf_total_osr_compile_count->inc();
2669 _total_osr_compile_count++;
2670 } else {
2671 if (UsePerfData) _perf_total_standard_compile_count->inc();
2672 _total_standard_compile_count++;
2673 }
2674 }
2675 // set the current method for the thread to null
2676 if (UsePerfData) counters->set_current_method("");
2677 }
2678
2726 }
2727
2728 if (!aggregate) {
2729 return;
2730 }
2731
2732 elapsedTimer standard_compilation = CompileBroker::_t_standard_compilation;
2733 elapsedTimer osr_compilation = CompileBroker::_t_osr_compilation;
2734 elapsedTimer total_compilation = CompileBroker::_t_total_compilation;
2735
2736 uint standard_bytes_compiled = CompileBroker::_sum_standard_bytes_compiled;
2737 uint osr_bytes_compiled = CompileBroker::_sum_osr_bytes_compiled;
2738
2739 uint standard_compile_count = CompileBroker::_total_standard_compile_count;
2740 uint osr_compile_count = CompileBroker::_total_osr_compile_count;
2741 uint total_compile_count = CompileBroker::_total_compile_count;
2742 uint total_bailout_count = CompileBroker::_total_bailout_count;
2743 uint total_invalidated_count = CompileBroker::_total_invalidated_count;
2744
2745 uint nmethods_code_size = CompileBroker::_sum_nmethod_code_size;
2746 uint largest_nmethod_code_size = CompileBroker::_largest_nmethod_code_size;
2747 uint nmethods_size = CompileBroker::_sum_nmethod_size;
2748
2749 tty->cr();
2750 tty->print_cr("Accumulated compiler times");
2751 tty->print_cr("----------------------------------------------------------");
2752 //0000000000111111111122222222223333333333444444444455555555556666666666
2753 //0123456789012345678901234567890123456789012345678901234567890123456789
2754 tty->print_cr(" Total compilation time : %7.3f s", total_compilation.seconds());
2755 tty->print_cr(" Standard compilation : %7.3f s, Average : %2.3f s",
2756 standard_compilation.seconds(),
2757 standard_compile_count == 0 ? 0.0 : standard_compilation.seconds() / standard_compile_count);
2758 tty->print_cr(" Bailed out compilation : %7.3f s, Average : %2.3f s",
2759 CompileBroker::_t_bailedout_compilation.seconds(),
2760 total_bailout_count == 0 ? 0.0 : CompileBroker::_t_bailedout_compilation.seconds() / total_bailout_count);
2761 tty->print_cr(" On stack replacement : %7.3f s, Average : %2.3f s",
2762 osr_compilation.seconds(),
2763 osr_compile_count == 0 ? 0.0 : osr_compilation.seconds() / osr_compile_count);
2764 tty->print_cr(" Invalidated : %7.3f s, Average : %2.3f s",
2765 CompileBroker::_t_invalidated_compilation.seconds(),
2766 total_invalidated_count == 0 ? 0.0 : CompileBroker::_t_invalidated_compilation.seconds() / total_invalidated_count);
2780 JVMCICompiler *jvmci_comp = JVMCICompiler::instance(false, JavaThread::current_or_null());
2781 if (jvmci_comp != nullptr && jvmci_comp != comp) {
2782 tty->cr();
2783 jvmci_comp->print_timers();
2784 }
2785 }
2786 #endif
2787
2788 tty->cr();
2789 tty->print_cr(" Total compiled methods : %8u methods", total_compile_count);
2790 tty->print_cr(" Standard compilation : %8u methods", standard_compile_count);
2791 tty->print_cr(" On stack replacement : %8u methods", osr_compile_count);
2792 uint tcb = osr_bytes_compiled + standard_bytes_compiled;
2793 tty->print_cr(" Total compiled bytecodes : %8u bytes", tcb);
2794 tty->print_cr(" Standard compilation : %8u bytes", standard_bytes_compiled);
2795 tty->print_cr(" On stack replacement : %8u bytes", osr_bytes_compiled);
2796 double tcs = total_compilation.seconds();
2797 uint bps = tcs == 0.0 ? 0 : (uint)(tcb / tcs);
2798 tty->print_cr(" Average compilation speed : %8u bytes/s", bps);
2799 tty->cr();
2800 tty->print_cr(" largest nmethod code size : %8u bytes", largest_nmethod_code_size);
2801 tty->print_cr(" nmethod code size : %8u bytes", nmethods_code_size);
2802 tty->print_cr(" nmethod total size : %8u bytes", nmethods_size);
2803 }
2804
2805 // Print general/accumulated JIT information.
2806 void CompileBroker::print_info(outputStream *out) {
2807 if (out == nullptr) out = tty;
2808 out->cr();
2809 out->print_cr("======================");
2810 out->print_cr(" General JIT info ");
2811 out->print_cr("======================");
2812 out->cr();
2813 out->print_cr(" JIT is : %7s", should_compile_new_jobs() ? "on" : "off");
2814 out->print_cr(" Compiler threads : %7d", (int)CICompilerCount);
2815 out->cr();
2816 out->print_cr("CodeCache overview");
2817 out->print_cr("--------------------------------------------------------");
2818 out->cr();
2819 out->print_cr(" Reserved size : %7zu KB", CodeCache::max_capacity() / K);
2820 out->print_cr(" Committed size : %7zu KB", CodeCache::capacity() / K);
|