jdk-sandbox: comparison hotspot/src/share/vm/opto/chaitin.cpp

equal deleted inserted replaced

-:19021f626ad2
+:9ad70cd32368
 , _oldphi(unique)
 #ifndef PRODUCT
 , _trace_spilling(TraceSpilling || C->method_has_option("TraceSpilling"))
 #endif
 {
-NOT_PRODUCT( Compile::TracePhase t3("ctorChaitin", &_t_ctorChaitin, TimeCompiler); )
+Compile::TracePhase tp("ctorChaitin", &timers[_t_ctorChaitin]);
 _high_frequency_lrg = MIN2(double(OPTO_LRG_HIGH_FREQ), _cfg.get_outer_loop_frequency());
 // Build a list of basic blocks, sorted by frequency
 _blks = NEW_RESOURCE_ARRAY(Block *, _cfg.number_of_blocks());
 return found_projs;
 }
 // Renumber the live ranges to compact them.  Makes the IFG smaller.
 void PhaseChaitin::compact() {
+Compile::TracePhase tp("chaitinCompact", &timers[_t_chaitinCompact]);
 // Current the _uf_map contains a series of short chains which are headed
 // by a self-cycle.  All the chains run from big numbers to little numbers.
 // The Find() call chases the chains & shortens them for the next Find call.
 // We are going to change this structure slightly.  Numbers above a moving
 // wave 'i' are unchanged.  Numbers below 'j' point directly to their
 // Veify the graph before RA.
 verify(&live_arena);
 #endif
 {
-NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
 _live = NULL;                 // Mark live as being not available
 rm.reset_to_mark();           // Reclaim working storage
 IndexSet::reset_memory(C, &live_arena);
 ifg.init(_lrg_map.max_lrg_id()); // Empty IFG
 gather_lrg_masks( false );    // Collect LRG masks
 // derived pointer is made, but not beyond.  Really, they need to be live
 // across any GC point where the derived value is live.  So this code looks
 // at all the GC points, and "stretches" the live range of any base pointer
 // to the GC point.
 if (stretch_base_pointer_live_ranges(&live_arena)) {
-NOT_PRODUCT(Compile::TracePhase t3("computeLive (sbplr)", &_t_computeLive, TimeCompiler);)
+Compile::TracePhase tp("computeLive (sbplr)", &timers[_t_computeLive]);
 // Since some live range stretched, I need to recompute live
 _live = NULL;
 rm.reset_to_mark();         // Reclaim working storage
 IndexSet::reset_memory(C, &live_arena);
 ifg.init(_lrg_map.max_lrg_id());
 _live = &live;
 }
 // Create the interference graph using virtual copies
 build_ifg_virtual();  // Include stack slots this time
+// The IFG is/was triangular.  I am 'squaring it up' so Union can run
+// faster.  Union requires a 'for all' operation which is slow on the
+// triangular adjacency matrix (quick reminder: the IFG is 'sparse' -
+// meaning I can visit all the Nodes neighbors less than a Node in time
+// O(# of neighbors), but I have to visit all the Nodes greater than a
+// given Node and search them for an instance, i.e., time O(#MaxLRG)).
+_ifg->SquareUp();
 // Aggressive (but pessimistic) copy coalescing.
 // This pass works on virtual copies.  Any virtual copies which are not
 // coalesced get manifested as actual copies
 {
-// The IFG is/was triangular.  I am 'squaring it up' so Union can run
+Compile::TracePhase tp("chaitinCoalesce1", &timers[_t_chaitinCoalesce1]);
-// faster.  Union requires a 'for all' operation which is slow on the
-// triangular adjacency matrix (quick reminder: the IFG is 'sparse' -
-// meaning I can visit all the Nodes neighbors less than a Node in time
-// O(# of neighbors), but I have to visit all the Nodes greater than a
-// given Node and search them for an instance, i.e., time O(#MaxLRG)).
-_ifg->SquareUp();
 PhaseAggressiveCoalesce coalesce(*this);
 coalesce.coalesce_driver();
 // Insert un-coalesced copies.  Visit all Phis.  Where inputs to a Phi do
 // not match the Phi itself, insert a copy.
 }
 // After aggressive coalesce, attempt a first cut at coloring.
 // To color, we need the IFG and for that we need LIVE.
 {
-NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
 _live = NULL;
 rm.reset_to_mark();           // Reclaim working storage
 IndexSet::reset_memory(C, &live_arena);
 ifg.init(_lrg_map.max_lrg_id());
 gather_lrg_masks( true );
 NOT_PRODUCT(C->verify_graph_edges();)
 compact();                  // Compact LRGs; return new lower max lrg
 {
-NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
 _live = NULL;
 rm.reset_to_mark();         // Reclaim working storage
 IndexSet::reset_memory(C, &live_arena);
 ifg.init(_lrg_map.max_lrg_id()); // Build a new interference graph
 gather_lrg_masks( true );   // Collect intersect mask
 build_ifg_physical(&live_arena);
 _ifg->SquareUp();
 _ifg->Compute_Effective_Degree();
 // Only do conservative coalescing if requested
 if (OptoCoalesce) {
+Compile::TracePhase tp("chaitinCoalesce2", &timers[_t_chaitinCoalesce2]);
 // Conservative (and pessimistic) copy coalescing of those spills
 PhaseConservativeCoalesce coalesce(*this);
 // If max live ranges greater than cutoff, don't color the stack.
 // This cutoff can be larger than below since it is only done once.
 coalesce.coalesce_driver();
 compact(); // Compact LRGs; return new lower max lrg
 // Nuke the live-ness and interference graph and LiveRanGe info
 {
-NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
 _live = NULL;
 rm.reset_to_mark();         // Reclaim working storage
 IndexSet::reset_memory(C, &live_arena);
 ifg.init(_lrg_map.max_lrg_id());
 _ifg->SquareUp();
 _ifg->Compute_Effective_Degree();
 // Only do conservative coalescing if requested
 if (OptoCoalesce) {
+Compile::TracePhase tp("chaitinCoalesce3", &timers[_t_chaitinCoalesce3]);
 // Conservative (and pessimistic) copy coalescing
 PhaseConservativeCoalesce coalesce(*this);
 // Check for few live ranges determines how aggressive coalesce is.
 coalesce.coalesce_driver();
 }
 #define REGISTER_CONSTRAINED 16
 // Compute cost/area ratio, in case we spill.  Build the lo-degree list.
 void PhaseChaitin::cache_lrg_info( ) {
+Compile::TracePhase tp("chaitinCacheLRG", &timers[_t_chaitinCacheLRG]);
 for (uint i = 1; i < _lrg_map.max_lrg_id(); i++) {
 LRG &lrg = lrgs(i);
 // Check for being of low degree: means we can be trivially colored.
 // No more lo-degree no-copy live ranges to simplify
 }
 // Simplify the IFG by removing LRGs of low degree.
 void PhaseChaitin::Simplify( ) {
+Compile::TracePhase tp("chaitinSimplify", &timers[_t_chaitinSimplify]);
 while( 1 ) {                  // Repeat till simplified it all
 // May want to explore simplifying lo_degree before _lo_stk_degree.
 // This might result in more spills coloring into registers during
 // Select().
 // Select colors by re-inserting LRGs back into the IFG.  LRGs are re-inserted
 // in reverse order of removal.  As long as nothing of hi-degree was yanked,
 // everything going back is guaranteed a color.  Select that color.  If some
 // hi-degree LRG cannot get a color then we record that we must spill.
 uint PhaseChaitin::Select( ) {
+Compile::TracePhase tp("chaitinSelect", &timers[_t_chaitinSelect]);
 uint spill_reg = LRG::SPILL_REG;
 _max_reg = OptoReg::Name(0);  // Past max register used
 while( _simplified ) {
 // Pull next LRG from the simplified list - in reverse order of removal
 uint lidx = _simplified;
 // Stores.  Use-def chains are NOT preserved, but Node->LRG->reg maps are.
 void PhaseChaitin::fixup_spills() {
 // This function does only cisc spill work.
 if( !UseCISCSpill ) return;
-NOT_PRODUCT( Compile::TracePhase t3("fixupSpills", &_t_fixupSpills, TimeCompiler); )
+Compile::TracePhase tp("fixupSpills", &timers[_t_fixupSpills]);
 // Grab the Frame Pointer
 Node *fp = _cfg.get_root_block()->head()->in(1)->in(TypeFunc::FramePtr);
 // For all blocks

changeset 26913	9ad70cd32368
parent 25930	eae8b7490d2c
child 28648	102bdbb42723