< prev index next >

src/hotspot/share/opto/compile.hpp

Print this page

 400   ciMethod*             _last_tf_m;             // Cache for
 401   const TypeFunc*       _last_tf;               //  TypeFunc::make
 402   AliasType**           _alias_types;           // List of alias types seen so far.
 403   int                   _num_alias_types;       // Logical length of _alias_types
 404   int                   _max_alias_types;       // Physical length of _alias_types
 405   AliasCacheEntry       _alias_cache[AliasCacheSize]; // Gets aliases w/o data structure walking
 406 
 407   // Parsing, optimization
 408   PhaseGVN*             _initial_gvn;           // Results of parse-time PhaseGVN
 409   Unique_Node_List*     _for_igvn;              // Initial work-list for next round of Iterative GVN
 410 
 411   GrowableArray<CallGenerator*> _late_inlines;        // List of CallGenerators to be revisited after main parsing has finished.
 412   GrowableArray<CallGenerator*> _string_late_inlines; // same but for string operations
 413   GrowableArray<CallGenerator*> _boxing_late_inlines; // same but for boxing operations
 414 
 415   GrowableArray<CallGenerator*> _vector_reboxing_late_inlines; // same but for vector reboxing operations
 416 
 417   int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
 418   uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
 419 
 420   GrowableArray<RuntimeStub*>   _native_invokers;
 421 
 422   // Inlining may not happen in parse order which would make
 423   // PrintInlining output confusing. Keep track of PrintInlining
 424   // pieces in order.
 425   class PrintInliningBuffer : public CHeapObj<mtCompiler> {
 426    private:
 427     CallGenerator* _cg;
 428     stringStream   _ss;
 429     static const size_t default_stream_buffer_size = 128;
 430 
 431    public:
 432     PrintInliningBuffer()
 433       : _cg(NULL), _ss(default_stream_buffer_size) {}
 434 
 435     stringStream* ss()             { return &_ss; }
 436     CallGenerator* cg()            { return _cg; }
 437     void set_cg(CallGenerator* cg) { _cg = cg; }
 438   };
 439 
 440   stringStream* _print_inlining_stream;
 441   GrowableArray<PrintInliningBuffer*>* _print_inlining_list;

 968     _late_inlines.insert_before(_late_inlines_pos, cg);
 969     _late_inlines_pos++;
 970   }
 971 
 972   void              prepend_late_inline(CallGenerator* cg)    {
 973     _late_inlines.insert_before(0, cg);
 974   }
 975 
 976   void              add_string_late_inline(CallGenerator* cg) {
 977     _string_late_inlines.push(cg);
 978   }
 979 
 980   void              add_boxing_late_inline(CallGenerator* cg) {
 981     _boxing_late_inlines.push(cg);
 982   }
 983 
 984   void              add_vector_reboxing_late_inline(CallGenerator* cg) {
 985     _vector_reboxing_late_inlines.push(cg);
 986   }
 987 
 988   void add_native_invoker(RuntimeStub* stub);
 989 
 990   const GrowableArray<RuntimeStub*> native_invokers() const { return _native_invokers; }
 991 
 992   void remove_useless_nodes       (GrowableArray<Node*>&        node_list, Unique_Node_List &useful);
 993 
 994   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 995   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Node* dead);
 996 
 997   void remove_useless_coarsened_locks(Unique_Node_List& useful);
 998 
 999   void process_print_inlining();
1000   void dump_print_inlining();
1001 
1002   bool over_inlining_cutoff() const {
1003     if (!inlining_incrementally()) {
1004       return unique() > (uint)NodeCountInliningCutoff;
1005     } else {
1006       // Give some room for incremental inlining algorithm to "breathe"
1007       // and avoid thrashing when live node count is close to the limit.
1008       // Keep in mind that live_nodes() isn't accurate during inlining until
1009       // dead node elimination step happens (see Compile::inline_incrementally).
1010       return live_nodes() > (uint)LiveNodeCountInliningCutoff * 11 / 10;
1011     }

 400   ciMethod*             _last_tf_m;             // Cache for
 401   const TypeFunc*       _last_tf;               //  TypeFunc::make
 402   AliasType**           _alias_types;           // List of alias types seen so far.
 403   int                   _num_alias_types;       // Logical length of _alias_types
 404   int                   _max_alias_types;       // Physical length of _alias_types
 405   AliasCacheEntry       _alias_cache[AliasCacheSize]; // Gets aliases w/o data structure walking
 406 
 407   // Parsing, optimization
 408   PhaseGVN*             _initial_gvn;           // Results of parse-time PhaseGVN
 409   Unique_Node_List*     _for_igvn;              // Initial work-list for next round of Iterative GVN
 410 
 411   GrowableArray<CallGenerator*> _late_inlines;        // List of CallGenerators to be revisited after main parsing has finished.
 412   GrowableArray<CallGenerator*> _string_late_inlines; // same but for string operations
 413   GrowableArray<CallGenerator*> _boxing_late_inlines; // same but for boxing operations
 414 
 415   GrowableArray<CallGenerator*> _vector_reboxing_late_inlines; // same but for vector reboxing operations
 416 
 417   int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
 418   uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
 419 


 420   // Inlining may not happen in parse order which would make
 421   // PrintInlining output confusing. Keep track of PrintInlining
 422   // pieces in order.
 423   class PrintInliningBuffer : public CHeapObj<mtCompiler> {
 424    private:
 425     CallGenerator* _cg;
 426     stringStream   _ss;
 427     static const size_t default_stream_buffer_size = 128;
 428 
 429    public:
 430     PrintInliningBuffer()
 431       : _cg(NULL), _ss(default_stream_buffer_size) {}
 432 
 433     stringStream* ss()             { return &_ss; }
 434     CallGenerator* cg()            { return _cg; }
 435     void set_cg(CallGenerator* cg) { _cg = cg; }
 436   };
 437 
 438   stringStream* _print_inlining_stream;
 439   GrowableArray<PrintInliningBuffer*>* _print_inlining_list;

 966     _late_inlines.insert_before(_late_inlines_pos, cg);
 967     _late_inlines_pos++;
 968   }
 969 
 970   void              prepend_late_inline(CallGenerator* cg)    {
 971     _late_inlines.insert_before(0, cg);
 972   }
 973 
 974   void              add_string_late_inline(CallGenerator* cg) {
 975     _string_late_inlines.push(cg);
 976   }
 977 
 978   void              add_boxing_late_inline(CallGenerator* cg) {
 979     _boxing_late_inlines.push(cg);
 980   }
 981 
 982   void              add_vector_reboxing_late_inline(CallGenerator* cg) {
 983     _vector_reboxing_late_inlines.push(cg);
 984   }
 985 




 986   void remove_useless_nodes       (GrowableArray<Node*>&        node_list, Unique_Node_List &useful);
 987 
 988   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 989   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Node* dead);
 990 
 991   void remove_useless_coarsened_locks(Unique_Node_List& useful);
 992 
 993   void process_print_inlining();
 994   void dump_print_inlining();
 995 
 996   bool over_inlining_cutoff() const {
 997     if (!inlining_incrementally()) {
 998       return unique() > (uint)NodeCountInliningCutoff;
 999     } else {
1000       // Give some room for incremental inlining algorithm to "breathe"
1001       // and avoid thrashing when live node count is close to the limit.
1002       // Keep in mind that live_nodes() isn't accurate during inlining until
1003       // dead node elimination step happens (see Compile::inline_incrementally).
1004       return live_nodes() > (uint)LiveNodeCountInliningCutoff * 11 / 10;
1005     }
< prev index next >