diff --git a/src/share/vm/opto/block.cpp b/src/share/vm/opto/block.cpp index f9fec29359f1469ab4c165786eb5bc5288aebec9..f0599a19c7ac348a2f2e98c77646ab6018a9d375 100644 --- a/src/share/vm/opto/block.cpp +++ b/src/share/vm/opto/block.cpp @@ -393,7 +393,7 @@ uint PhaseCFG::build_cfg() { VectorSet visited(a); // Allocate stack with enough space to avoid frequent realloc - Node_Stack nstack(a, C->unique() >> 1); + Node_Stack nstack(a, C->live_nodes() >> 1); nstack.push(_root, 0); uint sum = 0; // Counter for blocks diff --git a/src/share/vm/opto/cfgnode.cpp b/src/share/vm/opto/cfgnode.cpp index 25223035f29e439927b16518235d4139eace78e0..85c6d51987943e08657832cb20ff150d11f7ff58 100644 --- a/src/share/vm/opto/cfgnode.cpp +++ b/src/share/vm/opto/cfgnode.cpp @@ -791,7 +791,7 @@ PhiNode* PhiNode::split_out_instance(const TypePtr* at, PhaseIterGVN *igvn) cons Compile *C = igvn->C; Arena *a = Thread::current()->resource_area(); Node_Array node_map = new Node_Array(a); - Node_Stack stack(a, C->unique() >> 4); + Node_Stack stack(a, C->live_nodes() >> 4); PhiNode *nphi = slice_memory(at); igvn->register_new_node_with_optimizer( nphi ); node_map.map(_idx, nphi); diff --git a/src/share/vm/opto/compile.cpp b/src/share/vm/opto/compile.cpp index 9db624794d66c58a6aeffce383b2834b7447aa61..cbfabd323c1c66b6c03501d944db75e2c12a4583 100644 --- a/src/share/vm/opto/compile.cpp +++ b/src/share/vm/opto/compile.cpp @@ -327,7 +327,7 @@ static inline bool not_a_node(const Node* n) { // Use breadth-first pass that records state in a Unique_Node_List, // recursive traversal is slower. void Compile::identify_useful_nodes(Unique_Node_List &useful) { - int estimated_worklist_size = unique(); + int estimated_worklist_size = live_nodes(); useful.map( estimated_worklist_size, NULL ); // preallocate space // Initialize worklist @@ -3212,8 +3212,8 @@ bool Compile::final_graph_reshaping() { Final_Reshape_Counts frc; // Visit everybody reachable! - // Allocate stack of size C->unique()/2 to avoid frequent realloc - Node_Stack nstack(unique() >> 1); + // Allocate stack of size C->live_nodes()/2 to avoid frequent realloc + Node_Stack nstack(live_nodes() >> 1); final_graph_reshaping_walk(nstack, root(), frc); // Check for unreachable (from below) code (i.e., infinite loops). diff --git a/src/share/vm/opto/domgraph.cpp b/src/share/vm/opto/domgraph.cpp index a7fa05327630e8136d98a83580aca60298010745..576506e1d93cece8e897de06170f8262c1b5e0a6 100644 --- a/src/share/vm/opto/domgraph.cpp +++ b/src/share/vm/opto/domgraph.cpp @@ -505,8 +505,8 @@ void PhaseIdealLoop::Dominators() { // Perform DFS search. Setup 'vertex' as DFS to vertex mapping. Setup // 'semi' as vertex to DFS mapping. Set 'parent' to DFS parent. int NTarjan::DFS( NTarjan *ntarjan, VectorSet &visited, PhaseIdealLoop *pil, uint *dfsorder) { - // Allocate stack of size C->unique()/8 to avoid frequent realloc - GrowableArray dfstack(pil->C->unique() >> 3); + // Allocate stack of size C->live_nodes()/8 to avoid frequent realloc + GrowableArray dfstack(pil->C->live_nodes() >> 3); Node *b = pil->C->root(); int dfsnum = 1; dfsorder[b->_idx] = dfsnum; // Cache parent's dfsnum for a later use diff --git a/src/share/vm/opto/gcm.cpp b/src/share/vm/opto/gcm.cpp index 9d7b1b43586c4b2563fe84d7a347fde71a293b33..c574998e17da11e0e583347862aa183a1bb493bb 100644 --- a/src/share/vm/opto/gcm.cpp +++ b/src/share/vm/opto/gcm.cpp @@ -118,8 +118,8 @@ void PhaseCFG::replace_block_proj_ctrl( Node *n ) { //------------------------------schedule_pinned_nodes-------------------------- // Set the basic block for Nodes pinned into blocks void PhaseCFG::schedule_pinned_nodes(VectorSet &visited) { - // Allocate node stack of size C->unique()+8 to avoid frequent realloc - GrowableArray spstack(C->unique() + 8); + // Allocate node stack of size C->live_nodes()+8 to avoid frequent realloc + GrowableArray spstack(C->live_nodes() + 8); spstack.push(_root); while (spstack.is_nonempty()) { Node* node = spstack.pop(); @@ -1285,7 +1285,7 @@ void PhaseCFG::global_code_motion() { visited.Clear(); Node_List stack(arena); // Pre-grow the list - stack.map((C->unique() >> 1) + 16, NULL); + stack.map((C->live_nodes() >> 1) + 16, NULL); if (!schedule_early(visited, stack)) { // Bailout without retry C->record_method_not_compilable("early schedule failed"); diff --git a/src/share/vm/opto/loopnode.cpp b/src/share/vm/opto/loopnode.cpp index 57066d902b134422f40d5c632629cbbf42277635..7fea1b43fce4b87e10675542680fbcd54f6bec3e 100644 --- a/src/share/vm/opto/loopnode.cpp +++ b/src/share/vm/opto/loopnode.cpp @@ -2230,7 +2230,7 @@ void PhaseIdealLoop::build_and_optimize(bool do_split_ifs, bool skip_loop_opts) // _nodes array holds the earliest legal controlling CFG node. // Allocate stack with enough space to avoid frequent realloc - int stack_size = (C->unique() >> 1) + 16; // (unique>>1)+16 from Java2D stats + int stack_size = (C->live_nodes() >> 1) + 16; // (live_nodes>>1)+16 from Java2D stats Node_Stack nstack( a, stack_size ); visited.Clear(); @@ -2686,7 +2686,7 @@ void PhaseIdealLoop::recompute_dom_depth() { } } if (_dom_stk == NULL) { - uint init_size = C->unique() / 100; // Guess that 1/100 is a reasonable initial size. + uint init_size = C->live_nodes() / 100; // Guess that 1/100 is a reasonable initial size. if (init_size < 10) init_size = 10; _dom_stk = new GrowableArray(init_size); } @@ -2776,8 +2776,8 @@ IdealLoopTree *PhaseIdealLoop::sort( IdealLoopTree *loop, IdealLoopTree *innermo // The sort is of size number-of-control-children, which generally limits // it to size 2 (i.e., I just choose between my 2 target loops). void PhaseIdealLoop::build_loop_tree() { - // Allocate stack of size C->unique()/2 to avoid frequent realloc - GrowableArray bltstack(C->unique() >> 1); + // Allocate stack of size C->live_nodes()/2 to avoid frequent realloc + GrowableArray bltstack(C->live_nodes() >> 1); Node *n = C->root(); bltstack.push(n); int pre_order = 1; @@ -3666,7 +3666,7 @@ void PhaseIdealLoop::dump_bad_graph(const char* msg, Node* n, Node* early, Node* void PhaseIdealLoop::dump( ) const { ResourceMark rm; Arena* arena = Thread::current()->resource_area(); - Node_Stack stack(arena, C->unique() >> 2); + Node_Stack stack(arena, C->live_nodes() >> 2); Node_List rpo_list; VectorSet visited(arena); visited.set(C->top()->_idx); diff --git a/src/share/vm/opto/matcher.cpp b/src/share/vm/opto/matcher.cpp index 179f3e14f5ceff1fc10860fe9b6656317f49bdec..f4097b35e75f5ec43619db29405013f3093593ea 100644 --- a/src/share/vm/opto/matcher.cpp +++ b/src/share/vm/opto/matcher.cpp @@ -335,14 +335,14 @@ void Matcher::match( ) { grow_new_node_array(C->unique()); // Reset node counter so MachNodes start with _idx at 0 - int nodes = C->unique(); // save value + int live_nodes = C->live_nodes(); C->set_unique(0); C->reset_dead_node_list(); // Recursively match trees from old space into new space. // Correct leaves of new-space Nodes; they point to old-space. _visited.Clear(); // Clear visit bits for xform call - C->set_cached_top_node(xform( C->top(), nodes )); + C->set_cached_top_node(xform( C->top(), live_nodes)); if (!C->failing()) { Node* xroot = xform( C->root(), 1 ); if (xroot == NULL) { @@ -995,7 +995,7 @@ class MStack: public Node_Stack { Node *Matcher::transform( Node *n ) { ShouldNotCallThis(); return n; } Node *Matcher::xform( Node *n, int max_stack ) { // Use one stack to keep both: child's node/state and parent's node/index - MStack mstack(max_stack * 2 * 2); // C->unique() * 2 * 2 + MStack mstack(max_stack * 2 * 2); // usually: C->live_nodes() * 2 * 2 mstack.push(n, Visit, NULL, -1); // set NULL as parent to indicate root while (mstack.is_nonempty()) { @@ -2021,8 +2021,8 @@ bool Matcher::is_bmi_pattern(Node *n, Node *m) { //------------------------------find_shared------------------------------------ // Set bits if Node is shared or otherwise a root void Matcher::find_shared( Node *n ) { - // Allocate stack of size C->unique() * 2 to avoid frequent realloc - MStack mstack(C->unique() * 2); + // Allocate stack of size C->live_nodes() * 2 to avoid frequent realloc + MStack mstack(C->live_nodes() * 2); // Mark nodes as address_visited if they are inputs to an address expression VectorSet address_visited(Thread::current()->resource_area()); mstack.push(n, Visit); // Don't need to pre-visit root node diff --git a/src/share/vm/opto/node.cpp b/src/share/vm/opto/node.cpp index dd3c0791511716725f9ab403b13606ff8e1d7d74..8bd7f89af7b984d50140091b38991bfa50ee2d0b 100644 --- a/src/share/vm/opto/node.cpp +++ b/src/share/vm/opto/node.cpp @@ -1749,7 +1749,7 @@ static void dump_nodes(const Node* start, int d, bool only_ctrl) { uint depth = (uint)ABS(d); int direction = d; Compile* C = Compile::current(); - GrowableArray nstack(C->unique()); + GrowableArray nstack(C->live_nodes()); nstack.append(s); int begin = 0; diff --git a/src/share/vm/opto/phaseX.cpp b/src/share/vm/opto/phaseX.cpp index 34851320651d4e27cbf6b3053f6ccf1d1f981299..2616f1187ad459daa269a95f0b576e6ec5b19b6a 100644 --- a/src/share/vm/opto/phaseX.cpp +++ b/src/share/vm/opto/phaseX.cpp @@ -783,7 +783,7 @@ void PhaseGVN::dead_loop_check( Node *n ) { //------------------------------PhaseIterGVN----------------------------------- // Initialize hash table to fresh and clean for +VerifyOpto PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn, const char *dummy ) : PhaseGVN(igvn,dummy), _worklist( ), - _stack(C->unique() >> 1), + _stack(C->live_nodes() >> 1), _delay_transform(false) { } @@ -800,7 +800,11 @@ PhaseIterGVN::PhaseIterGVN( PhaseIterGVN *igvn ) : PhaseGVN(igvn), // Initialize with previous PhaseGVN info from Parser PhaseIterGVN::PhaseIterGVN( PhaseGVN *gvn ) : PhaseGVN(gvn), _worklist(*C->for_igvn()), - _stack(C->unique() >> 1), +// TODO: Before incremental inlining it was allocated only once and it was fine. Now that +// the constructor is used in incremental inlining, this consumes too much memory: +// _stack(C->live_nodes() >> 1), +// So, as a band-aid, we replace this by: + _stack(C->comp_arena(), 32), _delay_transform(false) { uint max; @@ -1586,7 +1590,7 @@ Node *PhaseCCP::transform( Node *n ) { _nodes.map( n->_idx, new_node ); // Flag as having been cloned // Allocate stack of size _nodes.Size()/2 to avoid frequent realloc - GrowableArray trstack(C->unique() >> 1); + GrowableArray trstack(C->live_nodes() >> 1); trstack.push(new_node); // Process children of cloned node while ( trstack.is_nonempty() ) {