< prev index next >

src/hotspot/share/opto/compile.hpp

Print this page

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

 952     _late_inlines.insert_before(_late_inlines_pos, cg);
 953     _late_inlines_pos++;
 954   }
 955 
 956   void              prepend_late_inline(CallGenerator* cg)    {
 957     _late_inlines.insert_before(0, cg);
 958   }
 959 
 960   void              add_string_late_inline(CallGenerator* cg) {
 961     _string_late_inlines.push(cg);
 962   }
 963 
 964   void              add_boxing_late_inline(CallGenerator* cg) {
 965     _boxing_late_inlines.push(cg);
 966   }
 967 
 968   void              add_vector_reboxing_late_inline(CallGenerator* cg) {
 969     _vector_reboxing_late_inlines.push(cg);
 970   }
 971 
 972   void add_native_invoker(RuntimeStub* stub);
 973 
 974   const GrowableArray<RuntimeStub*> native_invokers() const { return _native_invokers; }
 975 
 976   void remove_useless_nodes       (GrowableArray<Node*>&        node_list, Unique_Node_List &useful);
 977 
 978   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 979   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Node* dead);
 980 
 981   void remove_useless_coarsened_locks(Unique_Node_List& useful);
 982 
 983   void process_print_inlining();
 984   void dump_print_inlining();
 985 
 986   bool over_inlining_cutoff() const {
 987     if (!inlining_incrementally()) {
 988       return unique() > (uint)NodeCountInliningCutoff;
 989     } else {
 990       // Give some room for incremental inlining algorithm to "breathe"
 991       // and avoid thrashing when live node count is close to the limit.
 992       // Keep in mind that live_nodes() isn't accurate during inlining until
 993       // dead node elimination step happens (see Compile::inline_incrementally).
 994       return live_nodes() > (uint)LiveNodeCountInliningCutoff * 11 / 10;
 995     }

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


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

 950     _late_inlines.insert_before(_late_inlines_pos, cg);
 951     _late_inlines_pos++;
 952   }
 953 
 954   void              prepend_late_inline(CallGenerator* cg)    {
 955     _late_inlines.insert_before(0, cg);
 956   }
 957 
 958   void              add_string_late_inline(CallGenerator* cg) {
 959     _string_late_inlines.push(cg);
 960   }
 961 
 962   void              add_boxing_late_inline(CallGenerator* cg) {
 963     _boxing_late_inlines.push(cg);
 964   }
 965 
 966   void              add_vector_reboxing_late_inline(CallGenerator* cg) {
 967     _vector_reboxing_late_inlines.push(cg);
 968   }
 969 




 970   void remove_useless_nodes       (GrowableArray<Node*>&        node_list, Unique_Node_List &useful);
 971 
 972   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 973   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Node* dead);
 974 
 975   void remove_useless_coarsened_locks(Unique_Node_List& useful);
 976 
 977   void process_print_inlining();
 978   void dump_print_inlining();
 979 
 980   bool over_inlining_cutoff() const {
 981     if (!inlining_incrementally()) {
 982       return unique() > (uint)NodeCountInliningCutoff;
 983     } else {
 984       // Give some room for incremental inlining algorithm to "breathe"
 985       // and avoid thrashing when live node count is close to the limit.
 986       // Keep in mind that live_nodes() isn't accurate during inlining until
 987       // dead node elimination step happens (see Compile::inline_incrementally).
 988       return live_nodes() > (uint)LiveNodeCountInliningCutoff * 11 / 10;
 989     }
< prev index next >