Mercurial > hg > graal-compiler
view src/share/vm/adlc/forms.hpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
author | tonyp |
---|---|
date | Wed, 19 Jan 2011 09:35:17 -0500 |
parents | f95d63e2154a |
children | 8c92982cbbc4 |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_ADLC_FORMS_HPP #define SHARE_VM_ADLC_FORMS_HPP // FORMS.HPP - ADL Parser Generic and Utility Forms Classes #define TRUE 1 #define FALSE 0 // DEFINITIONS OF LEGAL ATTRIBUTE TYPES #define INS_ATTR 0 #define OP_ATTR 1 // DEFINITIONS OF LEGAL CONSTRAINT TYPES // Class List class Form; class InstructForm; class MachNodeForm; class OperandForm; class OpClassForm; class AttributeForm; class RegisterForm; class PipelineForm; class SourceForm; class EncodeForm; class Component; class Constraint; class Predicate; class MatchRule; class Attribute; class Effect; class ExpandRule; class RewriteRule; class ConstructRule; class FormatRule; class Peephole; class EncClass; class Interface; class RegInterface; class ConstInterface; class MemInterface; class CondInterface; class Opcode; class InsEncode; class RegDef; class RegClass; class AllocClass; class ResourceForm; class PipeClassForm; class PeepMatch; class PeepConstraint; class PeepReplace; class MatchList; class ArchDesc; //------------------------------FormDict--------------------------------------- // Dictionary containing Forms, and objects derived from forms class FormDict { private: Dict _form; // map names, char*, to their Form* or NULL // Disable public use of constructor, copy-ctor, operator =, operator == FormDict( ); FormDict &operator =( const FormDict & ); // == compares two dictionaries; they must have the same keys (their keys // must match using CmpKey) and they must have the same values (pointer // comparison). If so 1 is returned, if not 0 is returned. bool operator ==(const FormDict &d) const; // Compare dictionaries for equal public: // cmp is a key comparision routine. hash is a routine to hash a key. // FormDict( CmpKey cmp, Hash hash ); FormDict( CmpKey cmp, Hash hash, Arena *arena ); FormDict( const FormDict & fd ); // Deep-copy guts ~FormDict(); // Return # of key-value pairs in dict int Size(void) const; // Insert inserts the given key-value pair into the dictionary. The prior // value of the key is returned; NULL if the key was not previously defined. const Form *Insert(const char *name, Form *form); // A new key-value // Find finds the value of a given key; or NULL if not found. // The dictionary is NOT changed. const Form *operator [](const char *name) const; // Do a lookup void dump(); }; // ***** Master Class for ADL Parser Forms ***** //------------------------------Form------------------------------------------- class Form { public: static Arena *arena; // arena used by forms private: static Arena *generate_arena(); // allocate arena used by forms protected: int _ftype; // Indicator for derived class type public: // Public Data Form *_next; // Next pointer for form lists int _linenum; // Line number for debugging // Dynamic type check for common forms. virtual OpClassForm *is_opclass() const; virtual OperandForm *is_operand() const; virtual InstructForm *is_instruction() const; virtual MachNodeForm *is_machnode() const; virtual AttributeForm *is_attribute() const; virtual Effect *is_effect() const; virtual ResourceForm *is_resource() const; virtual PipeClassForm *is_pipeclass() const; // Check if this form is an operand usable for cisc-spilling virtual bool is_cisc_reg(FormDict &globals) const { return false; } virtual bool is_cisc_mem(FormDict &globals) const { return false; } // Public Methods Form(int formType=0, int line=0) : _next(NULL), _linenum(line), _ftype(formType) { }; ~Form() {}; virtual bool ideal_only() const { assert(0,"Check of ideal status on non-instruction/operand form.\n"); return FALSE; } // Check constraints after parsing virtual bool verify() { return true; } virtual void dump() { output(stderr); } // Debug printer // Write info to output files virtual void output(FILE *fp) { fprintf(fp,"Form Output"); } public: // ADLC types, match the last character on ideal operands and instructions enum DataType { none = 0, // Not a simple type idealI = 1, // Integer type idealP = 2, // Pointer types, oop(s) idealL = 3, // Long type idealF = 4, // Float type idealD = 5, // Double type idealB = 6, // Byte type idealC = 7, // Char type idealS = 8, // String type idealN = 9 // Narrow oop types }; // Convert ideal name to a DataType, return DataType::none if not a 'ConX' Form::DataType ideal_to_const_type(const char *ideal_type_name) const; // Convert ideal name to a DataType, return DataType::none if not a 'sRegX Form::DataType ideal_to_sReg_type(const char *name) const; // Convert ideal name to a DataType, return DataType::none if not a 'RegX Form::DataType ideal_to_Reg_type(const char *name) const; // Convert ideal name to a DataType, return DataType::none if not a 'LoadX Form::DataType is_load_from_memory(const char *opType) const; // Convert ideal name to a DataType, return DataType::none if not a 'StoreX Form::DataType is_store_to_memory(const char *opType) const; // ADLC call types, matched with ideal world enum CallType { invalid_type = 0, // invalid call type JAVA_STATIC = 1, // monomorphic entry JAVA_DYNAMIC = 2, // possibly megamorphic, inline cache call JAVA_COMPILED = 3, // callee will be compiled java JAVA_INTERP = 4, // callee will be executed by interpreter JAVA_NATIVE = 5, // native entrypoint JAVA_RUNTIME = 6, // runtime entrypoint JAVA_LEAF = 7 // calling leaf }; // Interface types for operands and operand classes enum InterfaceType { no_interface = 0, // unknown or inconsistent interface type constant_interface = 1, // interface to constants register_interface = 2, // interface to registers memory_interface = 3, // interface to memory conditional_interface = 4 // interface for condition codes }; virtual Form::InterfaceType interface_type(FormDict &globals) const; enum CiscSpillInfo { Not_cisc_spillable = AdlcVMDeps::Not_cisc_spillable, Maybe_cisc_spillable = 0, Is_cisc_spillable = 1 // ... }; // LEGAL FORM TYPES enum { INS, OPER, OPCLASS, SRC, ADEF, REG, PIPE, CNST, PRED, ATTR, MAT, ENC, FOR, EXP, REW, EFF, RDEF, RCL, ACL, RES, PCL, PDEF, REGL, RESL, STAL, COMP, PEEP, RESO }; }; //------------------------------FormList--------------------------------------- class FormList { private: Form *_root; Form *_tail; Form *_cur; int _justReset; // Set immediately after reset Form *_cur2; // Nested iterator int _justReset2; public: void addForm(Form * entry) { if (_tail==NULL) { _root = _tail = _cur = entry;} else { _tail->_next = entry; _tail = entry;} }; Form * current() { return _cur; }; Form * iter() { if (_justReset) _justReset = 0; else if (_cur) _cur = _cur->_next; return _cur;}; void reset() { if (_root) {_cur = _root; _justReset = 1;} }; // Second iterator, state is internal Form * current2(){ return _cur2; }; Form * iter2() { if (_justReset2) _justReset2 = 0; else if (_cur2) _cur2 = _cur2->_next; return _cur2;}; void reset2() { if (_root) {_cur2 = _root; _justReset2 = 1;} }; int count() { int count = 0; reset(); for( Form *cur; (cur = iter()) != NULL; ) { ++count; }; return count; } void dump() { reset(); Form *cur; for(; (cur = iter()) != NULL; ) { cur->dump(); }; } bool verify() { bool verified = true; reset(); Form *cur; for(; (cur = iter()) != NULL; ) { if ( ! cur->verify() ) verified = false; }; return verified; } void output(FILE* fp) { reset(); Form *cur; for( ; (cur = iter()) != NULL; ) { cur->output(fp); }; } FormList() { _justReset = 1; _justReset2 = 1; _root = NULL; _tail = NULL; _cur = NULL; _cur2 = NULL;}; ~FormList(); }; //------------------------------NameList--------------------------------------- // Extendable list of pointers, <char *> class NameList { friend class PreserveIter; private: int _cur; // Insert next entry here; count of entries int _max; // Number of spaces allocated const char **_names; // Array of names protected: int _iter; // position during iteration bool _justReset; // Set immediately after reset public: static const char *_signal; // reserved user-defined string static const char *_signal2; // reserved user-defined string static const char *_signal3; // reserved user-defined string enum { Not_in_list = -1 }; void addName(const char *name); void add_signal(); void clear(); // Remove all entries int count() const; void reset(); // Reset iteration const char *iter(); // after reset(), first element : else next const char *current(); // return current element in iteration. const char *peek(int skip = 1); // returns element + skip in iteration if there is one bool current_is_signal(); // Return 'true' if current entry is signal bool is_signal(const char *entry); // Return true if entry is a signal bool search(const char *); // Search for a name in the list int index(const char *); // Return index of name in list const char *name (intptr_t index);// Return name at index in list void dump(); // output to stderr void output(FILE *fp); // Output list of names to 'fp' NameList(); ~NameList(); }; // Convenience class to preserve iteration state since iterators are // internal instead of being external. class PreserveIter { private: NameList* _list; int _iter; bool _justReset; public: PreserveIter(NameList* nl) { _list = nl; _iter = _list->_iter; _justReset = _list->_justReset; } ~PreserveIter() { _list->_iter = _iter; _list->_justReset = _justReset; } }; //------------------------------NameAndList------------------------------------ // Storage for a name and an associated list of names class NameAndList { private: const char *_name; NameList _list; public: NameAndList(char *name); ~NameAndList(); // Add to entries in list void add_entry(const char *entry); // Access the name and its associated list. const char *name() const; void reset(); const char *iter(); int count() { return _list.count(); } // Return the "index" entry in the list, zero-based const char *operator[](int index); void dump(); // output to stderr void output(FILE *fp); // Output list of names to 'fp' }; //------------------------------ComponentList--------------------------------- // Component lists always have match rule operands first, followed by parameter // operands which do not appear in the match list (in order of declaration). class ComponentList : private NameList { private: int _matchcnt; // Count of match rule operands public: // This is a batch program. (And I have a destructor bug!) void operator delete( void *ptr ) {} void insert(Component *component, bool mflag); void insert(const char *name, const char *opType, int usedef, bool mflag); int count(); int match_count() { return _matchcnt; } // Get count of match rule opers Component *iter(); // after reset(), first element : else next Component *match_iter(); // after reset(), first element : else next Component *post_match_iter(); // after reset(), first element : else next void reset(); // Reset iteration Component *current(); // return current element in iteration. // Return element at "position", else NULL Component *operator[](int position); Component *at(int position) { return (*this)[position]; } // Return first component having this name. const Component *search(const char *name); // Return number of USEs + number of DEFs int num_operands(); // Return zero-based position in list; -1 if not in list. int operand_position(const char *name, int usedef); // Find position for this name, regardless of use/def information int operand_position(const char *name); // Find position for this name when looked up for output via "format" int operand_position_format(const char *name); // Find position for the Label when looked up for output via "format" int label_position(); // Find position for the Method when looked up for output via "format" int method_position(); void dump(); // output to stderr void output(FILE *fp); // Output list of names to 'fp' ComponentList(); ~ComponentList(); }; //------------------------------SourceForm------------------------------------- class SourceForm : public Form { private: public: // Public Data char *_code; // Buffer for storing code text // Public Methods SourceForm(char* code); ~SourceForm(); virtual const char* classname() { return "SourceForm"; } void dump(); // Debug printer void output(FILE *fp); // Write output files }; class HeaderForm : public SourceForm { public: HeaderForm(char* code) : SourceForm(code) { } virtual const char* classname() { return "HeaderForm"; } }; class PreHeaderForm : public SourceForm { public: PreHeaderForm(char* code) : SourceForm(code) { } virtual const char* classname() { return "PreHeaderForm"; } }; //------------------------------Expr------------------------------------------ #define STRING_BUFFER_LENGTH 2048 // class Expr represents integer expressions containing constants and addition // Value must be in range zero through maximum positive integer. 32bits. // Expected use: instruction and operand costs class Expr { public: enum { Zero = 0, Max = 0x7fffffff }; const char *_external_name; // if !NULL, then print this instead of _expr const char *_expr; int _min_value; int _max_value; Expr(); Expr(const char *cost); Expr(const char *name, const char *expression, int min_value, int max_value); Expr *clone() const; bool is_unknown() const { return (this == Expr::get_unknown()); } bool is_zero() const { return (_min_value == Expr::Zero && _max_value == Expr::Zero); } bool less_than_or_equal(const Expr *c) const { return (_max_value <= c->_min_value); } void add(const Expr *c); void add(const char *c); void add(const char *c, ArchDesc &AD); // check if 'c' is defined in <arch>.ad void set_external_name(const char *name) { _external_name = name; } const char *as_string() const { return (_external_name != NULL ? _external_name : _expr); } void print() const; void print_define(FILE *fp) const; void print_assert(FILE *fp) const; static Expr *get_unknown(); // Returns pointer to shared unknown cost instance static char *buffer() { return &external_buffer[0]; } static bool init_buffers(); // Fill buffers with 0 static bool check_buffers(); // if buffer use may have overflowed, assert private: static Expr *_unknown_expr; static char string_buffer[STRING_BUFFER_LENGTH]; static char external_buffer[STRING_BUFFER_LENGTH]; static bool _init_buffers; const char *compute_expr(const Expr *c1, const Expr *c2); // cost as string after adding 'c1' and 'c2' int compute_min (const Expr *c1, const Expr *c2); // minimum after adding 'c1' and 'c2' int compute_max (const Expr *c1, const Expr *c2); // maximum after adding 'c1' and 'c2' const char *compute_external(const Expr *c1, const Expr *c2); // external name after adding 'c1' and 'c2' }; //------------------------------ExprDict--------------------------------------- // Dictionary containing Exprs class ExprDict { private: Dict _expr; // map names, char*, to their Expr* or NULL NameList _defines; // record the order of definitions entered with define call // Disable public use of constructor, copy-ctor, operator =, operator == ExprDict( ); ExprDict( const ExprDict & ); // Deep-copy guts ExprDict &operator =( const ExprDict & ); // == compares two dictionaries; they must have the same keys (their keys // must match using CmpKey) and they must have the same values (pointer // comparison). If so 1 is returned, if not 0 is returned. bool operator ==(const ExprDict &d) const; // Compare dictionaries for equal public: // cmp is a key comparision routine. hash is a routine to hash a key. ExprDict( CmpKey cmp, Hash hash, Arena *arena ); ~ExprDict(); // Return # of key-value pairs in dict int Size(void) const; // define inserts the given key-value pair into the dictionary, // and records the name in order for later output, ... const Expr *define(const char *name, Expr *expr); // Insert inserts the given key-value pair into the dictionary. The prior // value of the key is returned; NULL if the key was not previously defined. const Expr *Insert(const char *name, Expr *expr); // A new key-value // Find finds the value of a given key; or NULL if not found. // The dictionary is NOT changed. const Expr *operator [](const char *name) const; // Do a lookup void print_defines(FILE *fp); void print_asserts(FILE *fp); void dump(); }; #endif // SHARE_VM_ADLC_FORMS_HPP