archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-22 03:54:33 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8030976: Untaken paths should be more vigorously pruned at highest optimization level

Browse source 
Reviewed-by: roland, vlivanov
This commit is contained in:
Rickard Bäckman 2014-05-22 13:42:44 +02:00
parent 0915147727
commit 8bd4b5624c
5 changed files with 14 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

75
hotspot/src/share/vm/opto/parse2.cpp
View file

@ -897,53 +897,12 @@ bool Parse::seems_never_taken(float prob) {
// if a path is never taken, its controlling comparison is
// already acting in a stable fashion. If the comparison
// seems stable, we will put an expensive uncommon trap
// on the untaken path. To be conservative, and to allow
// partially executed counted loops to be compiled fully,
// we will plant uncommon traps only after pointer comparisons.
// on the untaken path.
bool Parse::seems_stable_comparison(BoolTest::mask btest, Node* cmp) {
for (int depth = 4; depth > 0; depth--) {
// The following switch can find CmpP here over half the time for
// dynamic language code rich with type tests.
// Code using counted loops or array manipulations (typical
// of benchmarks) will have many (>80%) CmpI instructions.
switch (cmp->Opcode()) {
case Op_CmpP:
// A never-taken null check looks like CmpP/BoolTest::eq.
// These certainly should be closed off as uncommon traps.
if (btest == BoolTest::eq)
return true;
// A never-failed type check looks like CmpP/BoolTest::ne.
// Let's put traps on those, too, so that we don't have to compile
// unused paths with indeterminate dynamic type information.
if (ProfileDynamicTypes)
return true;
return false;
case Op_CmpI:
// A small minority (< 10%) of CmpP are masked as CmpI,
// as if by boolean conversion ((p == q? 1: 0) != 0).
// Detect that here, even if it hasn't optimized away yet.
// Specifically, this covers the 'instanceof' operator.
if (btest == BoolTest::ne || btest == BoolTest::eq) {
if (_gvn.type(cmp->in(2))->singleton() &&
cmp->in(1)->is_Phi()) {
PhiNode* phi = cmp->in(1)->as_Phi();
int true_path = phi->is_diamond_phi();
if (true_path > 0 &&
_gvn.type(phi->in(1))->singleton() &&
_gvn.type(phi->in(2))->singleton()) {
// phi->region->if_proj->ifnode->bool->cmp
BoolNode* bol = phi->in(0)->in(1)->in(0)->in(1)->as_Bool();
btest = bol->_test._test;
cmp = bol->in(1);
continue;
}
}
}
return false;
}
if (C->too_many_traps(method(), bci(), Deoptimization::Reason_unstable_if)) {
return false;
}
return false;
return true;
}
//-------------------------------repush_if_args--------------------------------
@ -1182,32 +1141,8 @@ void Parse::adjust_map_after_if(BoolTest::mask btest, Node* c, float prob,
bool is_fallthrough = (path == successor_for_bci(iter().next_bci()));
if (seems_never_taken(prob) && seems_stable_comparison(btest, c)) {
// If this might possibly turn into an implicit null check,
// and the null has never yet been seen, we need to generate
// an uncommon trap, so as to recompile instead of suffering
// with very slow branches. (We'll get the slow branches if
// the program ever changes phase and starts seeing nulls here.)
//
// We do not inspect for a null constant, since a node may
// optimize to 'null' later on.
//
// Null checks, and other tests which expect inequality,
// show btest == BoolTest::eq along the non-taken branch.
// On the other hand, type tests, must-be-null tests,
// and other tests which expect pointer equality,
// show btest == BoolTest::ne along the non-taken branch.
// We prune both types of branches if they look unused.
repush_if_args();
// We need to mark this branch as taken so that if we recompile we will
// see that it is possible. In the tiered system the interpreter doesn't
// do profiling and by the time we get to the lower tier from the interpreter
// the path may be cold again. Make sure it doesn't look untaken
if (is_fallthrough) {
profile_not_taken_branch(!ProfileInterpreter);
} else {
profile_taken_branch(iter().get_dest(), !ProfileInterpreter);
}
uncommon_trap(Deoptimization::Reason_unreached,
uncommon_trap(Deoptimization::Reason_unstable_if,
Deoptimization::Action_reinterpret,
NULL,
(is_fallthrough ? "taken always" : "taken never"));