stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8150720: Cleanup code around PrintOptoStatistics

Browse Source 
Reviewed-by: kvn, shade, vlivanov
This commit is contained in:
Claes Redestad 2016-02-29 15:05:45 +01:00
parent babca85232
commit ea5a3565b8
8 changed files with 56 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
hotspot/src/share/vm/opto/graphKit.cpp
View File

@ -1179,8 +1179,10 @@ Node* GraphKit::load_array_length(Node* array) {
// Helper function to do a NULL pointer check. Returned value is // Helper function to do a NULL pointer check. Returned value is
// the incoming address with NULL casted away. You are allowed to use the // the incoming address with NULL casted away. You are allowed to use the
// not-null value only if you are control dependent on the test. // not-null value only if you are control dependent on the test.
#ifndef PRODUCT
extern int explicit_null_checks_inserted, extern int explicit_null_checks_inserted,
explicit_null_checks_elided; explicit_null_checks_elided;
#endif
Node* GraphKit::null_check_common(Node* value, BasicType type, Node* GraphKit::null_check_common(Node* value, BasicType type,
// optional arguments for variations: // optional arguments for variations:
bool assert_null, bool assert_null,
@ -1193,7 +1195,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
value = cast_not_null(value); // Make it appear to be non-null (4962416). value = cast_not_null(value); // Make it appear to be non-null (4962416).
return value; return value;
} }
explicit_null_checks_inserted++; NOT_PRODUCT(explicit_null_checks_inserted++);
// Construct NULL check // Construct NULL check
Node *chk = NULL; Node *chk = NULL;
@ -1233,7 +1235,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
// See if the type is contained in NULL_PTR. // See if the type is contained in NULL_PTR.
// If so, then the value is already null. // If so, then the value is already null.
if (t->higher_equal(TypePtr::NULL_PTR)) { if (t->higher_equal(TypePtr::NULL_PTR)) {
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
return value; // Elided null assert quickly! return value; // Elided null assert quickly!
} }
} else { } else {
@ -1242,7 +1244,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
// type. In other words, "value" was not-null. // type. In other words, "value" was not-null.
if (t->meet(TypePtr::NULL_PTR) != t->remove_speculative()) { if (t->meet(TypePtr::NULL_PTR) != t->remove_speculative()) {
// same as: if (!TypePtr::NULL_PTR->higher_equal(t)) ... // same as: if (!TypePtr::NULL_PTR->higher_equal(t)) ...
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
return value; // Elided null check quickly! return value; // Elided null check quickly!
} }
} }
@ -1282,7 +1284,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
set_control(cfg); set_control(cfg);
Node *res = cast_not_null(value); Node *res = cast_not_null(value);
set_control(oldcontrol); set_control(oldcontrol);
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
return res; return res;
} }
cfg = IfNode::up_one_dom(cfg, /*linear_only=*/ true); cfg = IfNode::up_one_dom(cfg, /*linear_only=*/ true);
@ -1326,15 +1328,18 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN); IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
Node* null_true = _gvn.transform( new IfFalseNode(iff)); Node* null_true = _gvn.transform( new IfFalseNode(iff));
set_control( _gvn.transform( new IfTrueNode(iff))); set_control( _gvn.transform( new IfTrueNode(iff)));
if (null_true == top()) #ifndef PRODUCT
if (null_true == top()) {
explicit_null_checks_elided++; explicit_null_checks_elided++;
}
#endif
(*null_control) = null_true; (*null_control) = null_true;
} else { } else {
BuildCutout unless(this, tst, ok_prob); BuildCutout unless(this, tst, ok_prob);
// Check for optimizer eliding test at parse time // Check for optimizer eliding test at parse time
if (stopped()) { if (stopped()) {
// Failure not possible; do not bother making uncommon trap. // Failure not possible; do not bother making uncommon trap.
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
} else if (assert_null) { } else if (assert_null) {
uncommon_trap(reason, uncommon_trap(reason,
Deoptimization::Action_make_not_entrant, Deoptimization::Action_make_not_entrant,

20
hotspot/src/share/vm/opto/ifnode.cpp
View File

@ -40,7 +40,9 @@
// Optimization - Graph Style // Optimization - Graph Style
#ifndef PRODUCT
extern int explicit_null_checks_elided; extern int explicit_null_checks_elided;
#endif
//============================================================================= //=============================================================================
//------------------------------Value------------------------------------------ //------------------------------Value------------------------------------------
@ -1504,24 +1506,28 @@ Node* IfNode::search_identical(int dist) {
Node* prev_dom = this; Node* prev_dom = this;
int op = Opcode(); int op = Opcode();
// Search up the dominator tree for an If with an identical test // Search up the dominator tree for an If with an identical test
while( dom->Opcode() != op || // Not same opcode? while (dom->Opcode() != op || // Not same opcode?
dom->in(1) != in(1) || // Not same input 1? dom->in(1) != in(1) || // Not same input 1?
(req() == 3 && dom->in(2) != in(2)) || // Not same input 2? (req() == 3 && dom->in(2) != in(2)) || // Not same input 2?
prev_dom->in(0) != dom ) { // One path of test does not dominate? prev_dom->in(0) != dom) { // One path of test does not dominate?
if( dist < 0 ) return NULL; if (dist < 0) return NULL;
dist--; dist--;
prev_dom = dom; prev_dom = dom;
dom = up_one_dom( dom ); dom = up_one_dom(dom);
if( !dom ) return NULL; if (!dom) return NULL;
} }
// Check that we did not follow a loop back to ourselves // Check that we did not follow a loop back to ourselves
if( this == dom ) if (this == dom) {
return NULL; return NULL;
}
if( dist > 2 ) // Add to count of NULL checks elided #ifndef PRODUCT
if (dist > 2) { // Add to count of NULL checks elided
explicit_null_checks_elided++; explicit_null_checks_elided++;
}
#endif
return prev_dom; return prev_dom;
} }

2
hotspot/src/share/vm/opto/lcm.cpp
View File

@ -348,8 +348,10 @@ void PhaseCFG::implicit_null_check(Block* block, Node *proj, Node *val, int allo
} }
// ---- Found an implicit null check // ---- Found an implicit null check
#ifndef PRODUCT
extern int implicit_null_checks; extern int implicit_null_checks;
implicit_null_checks++; implicit_null_checks++;
#endif
if( is_decoden ) { if( is_decoden ) {
// Check if we need to hoist decodeHeapOop_not_null first. // Check if we need to hoist decodeHeapOop_not_null first.

2
hotspot/src/share/vm/opto/matcher.cpp
View File

@ -2415,8 +2415,10 @@ void Matcher::collect_null_checks( Node *proj, Node *orig_proj ) {
bool push_it = false; bool push_it = false;
if( proj->Opcode() == Op_IfTrue ) { if( proj->Opcode() == Op_IfTrue ) {
#ifndef PRODUCT
extern int all_null_checks_found; extern int all_null_checks_found;
all_null_checks_found++; all_null_checks_found++;
#endif
if( b->_test._test == BoolTest::ne ) { if( b->_test._test == BoolTest::ne ) {
push_it = true; push_it = true;
} }

28
hotspot/src/share/vm/opto/node.cpp
View File

@ -576,17 +576,11 @@ void Node::setup_is_top() {
//------------------------------~Node------------------------------------------ //------------------------------~Node------------------------------------------
// Fancy destructor; eagerly attempt to reclaim Node numberings and storage // Fancy destructor; eagerly attempt to reclaim Node numberings and storage
extern int reclaim_idx ;
extern int reclaim_in ;
extern int reclaim_node;
void Node::destruct() { void Node::destruct() {
// Eagerly reclaim unique Node numberings // Eagerly reclaim unique Node numberings
Compile* compile = Compile::current(); Compile* compile = Compile::current();
if ((uint)_idx+1 == compile->unique()) { if ((uint)_idx+1 == compile->unique()) {
compile->set_unique(compile->unique()-1); compile->set_unique(compile->unique()-1);
#ifdef ASSERT
reclaim_idx++;
#endif
} }
// Clear debug info: // Clear debug info:
Node_Notes* nn = compile->node_notes_at(_idx); Node_Notes* nn = compile->node_notes_at(_idx);
@ -604,43 +598,25 @@ void Node::destruct() {
int out_edge_size = _outmax*sizeof(void*); int out_edge_size = _outmax*sizeof(void*);
char *edge_end = ((char*)_in) + edge_size; char *edge_end = ((char*)_in) + edge_size;
char *out_array = (char*)(_out == NO_OUT_ARRAY? NULL: _out); char *out_array = (char*)(_out == NO_OUT_ARRAY? NULL: _out);
char *out_edge_end = out_array + out_edge_size;
int node_size = size_of(); int node_size = size_of();
// Free the output edge array // Free the output edge array
if (out_edge_size > 0) { if (out_edge_size > 0) {
#ifdef ASSERT
if( out_edge_end == compile->node_arena()->hwm() )
reclaim_in += out_edge_size; // count reclaimed out edges with in edges
#endif
compile->node_arena()->Afree(out_array, out_edge_size); compile->node_arena()->Afree(out_array, out_edge_size);
} }
// Free the input edge array and the node itself // Free the input edge array and the node itself
if( edge_end == (char*)this ) { if( edge_end == (char*)this ) {
#ifdef ASSERT
if( edge_end+node_size == compile->node_arena()->hwm() ) {
reclaim_in += edge_size;
reclaim_node+= node_size;
}
#else
// It was; free the input array and object all in one hit // It was; free the input array and object all in one hit
#ifndef ASSERT
compile->node_arena()->Afree(_in,edge_size+node_size); compile->node_arena()->Afree(_in,edge_size+node_size);
#endif #endif
} else { } else {
// Free just the input array // Free just the input array
#ifdef ASSERT
if( edge_end == compile->node_arena()->hwm() )
reclaim_in += edge_size;
#endif
compile->node_arena()->Afree(_in,edge_size); compile->node_arena()->Afree(_in,edge_size);
// Free just the object // Free just the object
#ifdef ASSERT #ifndef ASSERT
if( ((char*)this) + node_size == compile->node_arena()->hwm() )
reclaim_node+= node_size;
#else
compile->node_arena()->Afree(this,node_size); compile->node_arena()->Afree(this,node_size);
#endif #endif
} }

10
hotspot/src/share/vm/opto/parse.hpp
View File

@ -104,13 +104,6 @@ public:
// For temporary (stack-allocated, stateless) ilts: // For temporary (stack-allocated, stateless) ilts:
InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms, float site_invoke_ratio, int max_inline_level); InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms, float site_invoke_ratio, int max_inline_level);
// InlineTree enum
enum InlineStyle {
Inline_do_not_inline = 0, //
Inline_cha_is_monomorphic = 1, //
Inline_type_profile_monomorphic = 2 //
};
// See if it is OK to inline. // See if it is OK to inline.
// The receiver is the inline tree for the caller. // The receiver is the inline tree for the caller.
// //
@ -349,9 +342,6 @@ class Parse : public GraphKit {
Block* _block; // block currently getting parsed Block* _block; // block currently getting parsed
ciBytecodeStream _iter; // stream of this method's bytecodes ciBytecodeStream _iter; // stream of this method's bytecodes
int _blocks_merged; // Progress meter: state merges from BB preds
int _blocks_parsed; // Progress meter: BBs actually parsed
const FastLockNode* _synch_lock; // FastLockNode for synchronized method const FastLockNode* _synch_lock; // FastLockNode for synchronized method
#ifndef PRODUCT #ifndef PRODUCT

45
hotspot/src/share/vm/opto/parse1.cpp
View File

@ -45,6 +45,7 @@
// the most. Some of the non-static variables are needed in bytecodeInfo.cpp // the most. Some of the non-static variables are needed in bytecodeInfo.cpp
// and eventually should be encapsulated in a proper class (gri 8/18/98). // and eventually should be encapsulated in a proper class (gri 8/18/98).
#ifndef PRODUCT
int nodes_created = 0; int nodes_created = 0;
int methods_parsed = 0; int methods_parsed = 0;
int methods_seen = 0; int methods_seen = 0;
@ -53,42 +54,42 @@ int blocks_seen = 0;
int explicit_null_checks_inserted = 0; int explicit_null_checks_inserted = 0;
int explicit_null_checks_elided = 0; int explicit_null_checks_elided = 0;
int all_null_checks_found = 0, implicit_null_checks = 0; int all_null_checks_found = 0;
int implicit_null_throws = 0; int implicit_null_checks = 0;
int reclaim_idx = 0;
int reclaim_in = 0;
int reclaim_node = 0;
#ifndef PRODUCT
bool Parse::BytecodeParseHistogram::_initialized = false; bool Parse::BytecodeParseHistogram::_initialized = false;
uint Parse::BytecodeParseHistogram::_bytecodes_parsed [Bytecodes::number_of_codes]; uint Parse::BytecodeParseHistogram::_bytecodes_parsed [Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_nodes_constructed[Bytecodes::number_of_codes]; uint Parse::BytecodeParseHistogram::_nodes_constructed[Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_nodes_transformed[Bytecodes::number_of_codes]; uint Parse::BytecodeParseHistogram::_nodes_transformed[Bytecodes::number_of_codes];
uint Parse::BytecodeParseHistogram::_new_values [Bytecodes::number_of_codes]; uint Parse::BytecodeParseHistogram::_new_values [Bytecodes::number_of_codes];
#endif
//------------------------------print_statistics------------------------------- //------------------------------print_statistics-------------------------------
#ifndef PRODUCT
void Parse::print_statistics() { void Parse::print_statistics() {
tty->print_cr("--- Compiler Statistics ---"); tty->print_cr("--- Compiler Statistics ---");
tty->print("Methods seen: %d Methods parsed: %d", methods_seen, methods_parsed); tty->print("Methods seen: %d Methods parsed: %d", methods_seen, methods_parsed);
tty->print(" Nodes created: %d", nodes_created); tty->print(" Nodes created: %d", nodes_created);
tty->cr(); tty->cr();
if (methods_seen != methods_parsed) if (methods_seen != methods_parsed) {
tty->print_cr("Reasons for parse failures (NOT cumulative):"); tty->print_cr("Reasons for parse failures (NOT cumulative):");
}
tty->print_cr("Blocks parsed: %d Blocks seen: %d", blocks_parsed, blocks_seen); tty->print_cr("Blocks parsed: %d Blocks seen: %d", blocks_parsed, blocks_seen);
if( explicit_null_checks_inserted ) if (explicit_null_checks_inserted) {
tty->print_cr("%d original NULL checks - %d elided (%2d%%); optimizer leaves %d,", explicit_null_checks_inserted, explicit_null_checks_elided, (100*explicit_null_checks_elided)/explicit_null_checks_inserted, all_null_checks_found); tty->print_cr("%d original NULL checks - %d elided (%2d%%); optimizer leaves %d,",
if( all_null_checks_found ) explicit_null_checks_inserted, explicit_null_checks_elided,
(100*explicit_null_checks_elided)/explicit_null_checks_inserted,
all_null_checks_found);
}
if (all_null_checks_found) {
tty->print_cr("%d made implicit (%2d%%)", implicit_null_checks, tty->print_cr("%d made implicit (%2d%%)", implicit_null_checks,
(100*implicit_null_checks)/all_null_checks_found); (100*implicit_null_checks)/all_null_checks_found);
if( implicit_null_throws ) }
if (SharedRuntime::_implicit_null_throws) {
tty->print_cr("%d implicit null exceptions at runtime", tty->print_cr("%d implicit null exceptions at runtime",
implicit_null_throws); SharedRuntime::_implicit_null_throws);
}
if( PrintParseStatistics && BytecodeParseHistogram::initialized() ) { if (PrintParseStatistics && BytecodeParseHistogram::initialized()) {
BytecodeParseHistogram::print(); BytecodeParseHistogram::print();
} }
} }
@ -495,7 +496,7 @@ Parse::Parse(JVMState* caller, ciMethod* parse_method, float expected_uses)
C->dependencies()->assert_evol_method(method()); C->dependencies()->assert_evol_method(method());
} }
methods_seen++; NOT_PRODUCT(methods_seen++);
// Do some special top-level things. // Do some special top-level things.
if (depth() == 1 && C->is_osr_compilation()) { if (depth() == 1 && C->is_osr_compilation()) {
@ -530,8 +531,8 @@ Parse::Parse(JVMState* caller, ciMethod* parse_method, float expected_uses)
} }
#endif #endif
methods_parsed++;
#ifndef PRODUCT #ifndef PRODUCT
methods_parsed++;
// add method size here to guarantee that inlined methods are added too // add method size here to guarantee that inlined methods are added too
if (CITime) if (CITime)
_total_bytes_compiled += method()->code_size(); _total_bytes_compiled += method()->code_size();
@ -652,7 +653,7 @@ void Parse::do_all_blocks() {
continue; continue;
} }
blocks_parsed++; NOT_PRODUCT(blocks_parsed++);
progress = true; progress = true;
if (block->is_loop_head() || block->is_handler() || has_irreducible && !block->is_ready()) { if (block->is_loop_head() || block->is_handler() || has_irreducible && !block->is_ready()) {
@ -712,9 +713,9 @@ void Parse::do_all_blocks() {
} }
} }
#ifndef PRODUCT
blocks_seen += block_count(); blocks_seen += block_count();
#ifndef PRODUCT
// Make sure there are no half-processed blocks remaining. // Make sure there are no half-processed blocks remaining.
// Every remaining unprocessed block is dead and may be ignored now. // Every remaining unprocessed block is dead and may be ignored now.
for (int rpo = 0; rpo < block_count(); rpo++) { for (int rpo = 0; rpo < block_count(); rpo++) {
@ -1446,7 +1447,6 @@ void Parse::do_one_block() {
assert(block()->is_merged(), "must be merged before being parsed"); assert(block()->is_merged(), "must be merged before being parsed");
block()->mark_parsed(); block()->mark_parsed();
++_blocks_parsed;
// Set iterator to start of block. // Set iterator to start of block.
iter().reset_to_bci(block()->start()); iter().reset_to_bci(block()->start());
@ -1596,9 +1596,6 @@ void Parse::merge_common(Parse::Block* target, int pnum) {
return; return;
} }
// Record that a new block has been merged.
++_blocks_merged;
// Make a region if we know there are multiple or unpredictable inputs. // Make a region if we know there are multiple or unpredictable inputs.
// (Also, if this is a plain fall-through, we might see another region, // (Also, if this is a plain fall-through, we might see another region,
// which must not be allowed into this block's map.) // which must not be allowed into this block's map.)

8
hotspot/src/share/vm/opto/parse2.cpp
View File

@ -44,8 +44,10 @@
#include "runtime/deoptimization.hpp" #include "runtime/deoptimization.hpp"
#include "runtime/sharedRuntime.hpp" #include "runtime/sharedRuntime.hpp"
#ifndef PRODUCT
extern int explicit_null_checks_inserted, extern int explicit_null_checks_inserted,
explicit_null_checks_elided; explicit_null_checks_elided;
#endif
//---------------------------------array_load---------------------------------- //---------------------------------array_load----------------------------------
void Parse::array_load(BasicType elem_type) { void Parse::array_load(BasicType elem_type) {
@ -997,7 +999,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
return; return;
} }
explicit_null_checks_inserted++; NOT_PRODUCT(explicit_null_checks_inserted++);
// Generate real control flow // Generate real control flow
Node *tst = _gvn.transform( new BoolNode( c, btest ) ); Node *tst = _gvn.transform( new BoolNode( c, btest ) );
@ -1013,7 +1015,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
set_control(iftrue); set_control(iftrue);
if (stopped()) { // Path is dead? if (stopped()) { // Path is dead?
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
if (C->eliminate_boxing()) { if (C->eliminate_boxing()) {
// Mark the successor block as parsed // Mark the successor block as parsed
branch_block->next_path_num(); branch_block->next_path_num();
@ -1033,7 +1035,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
set_control(iffalse); set_control(iffalse);
if (stopped()) { // Path is dead? if (stopped()) { // Path is dead?
explicit_null_checks_elided++; NOT_PRODUCT(explicit_null_checks_elided++);
if (C->eliminate_boxing()) { if (C->eliminate_boxing()) {
// Mark the successor block as parsed // Mark the successor block as parsed
next_block->next_path_num(); next_block->next_path_num();