Polaris: AbstractAccess.h Source File

AbstractAccess.h Go to the documentation of this file. #ifndef _ABSTRACTACCESS_H #define _ABSTRACTACCESS_H /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include <fstream.h> #include "ClassNames.h" /// extern int _ipa; /// A static global to hold the value of the ipa switch extern int _ipa_reasons; /// A static global to hold the value of the ipa_reasons switch extern int _ar_coalesce; /// A static global to hold the value of the ar_coalesce switch extern int _ar_aggregate; /// A static global to hold the value of the ar_aggregate switch extern int _ar_interleave; /// A static global to hold the value of the ar_interleave switch extern int _ar_match_dims; /// A static global to hold the value of the ar_match_dims switch extern int _ar_logging; /// A static global to hold the value of the ar_match_dims switch extern ofstream arlog; /// The file for writing the Access Region log. extern int _ar_leave_descr; /// Controls whether descriptors are left on statements or not extern int _ar_prtstats; /// Controls collecting and printing of statistics (ar_prtstats switch) extern int _ar_approx_thresh; /// Set the threshold for list size which causes the list to be replaced by /// a single "approximate LMAD" extern int _ar_effort; /// Controls how hard we work on simplifying a set of descriptors /// (scale of 1 to 10, 10 being to work the hardest) extern int _ar_reshape; extern ofstream stats_out; /// Controls collecting of array reshaping data, and writing it to /// the sequential output file opened on stats_out. /// enum AR_MONOTON { AR_PROVEN_NON_MONO, /// proven non-monotonic AR_PROVEN_MONO, /// proven monotonic AR_MONO_UNSURE, /// not sure of monotonicity - check at runtime AR_UNKNOWN_MONO }; /// enum AR_TYPE { AR_UNKNOWN, AR_READ, AR_WRITE, AR_READWRITE }; /// enum RED_OP { RED_OP_NONE, RED_OP_PLUS, RED_OP_MUL, RED_OP_MIN, RED_OP_MAX }; /// class ProgramUnit; class Statement; class Symbol; ///<class StmtRanges; class RangeAccessor; class UGraphIterator; #include "Collection/RefList.h" #include "AccessDimension.h" #include "Expression/Expression.h" class AbstractAccess : public Listable { friend class SimGraph; friend class SimBiGraph; protected: Symbol * _symbol; List<AccessDimension> _dims; Expression * _start; Expression * _correctness; ///< Correctness condition for this descriptor int _exec_pred; ///< index into global repository for execution predicate (from surrounding IF statements) ACCURACY _accuracy; Expression * _actual; ///< temporary storage for the actual array reference Statement * _actual_stmt; ///< Pointer to the statement where _actual resides. bool _read_only, _write_first, _imprecise_sorting, _possible_reduction, _possible_induction, _approximate; Statement * _summarized_to; ///< DO loop or other statement this access ///< is "summarized to". ProgramUnit * _pgm_summarized_to; ///< ProgramUnit of stmt "summarized_to" int _diagonal:1,_triangular:1,_subsub:1,_nonaffine:1,_monoton:4,_access_type:3, _visited:1,_no_overlap:3,_bytesize:6,_reduct_op:4; int _nesting_level; ///< Only through this statement, how many loops is the orig ///< access nested inside? ///< RefList<AbstractAccess> _outer; // Pointer to next-outer summarizations of this access ///< RefList<AbstractAccess> _inner; // Pointer to next-inner summarizations of this access public: AbstractAccess( ); AbstractAccess( const Symbol & sym, const List<AccessDimension> & dims, Expression * start ); AbstractAccess( const Symbol & sym, const List<AccessDimension> & dims, Expression * start, ACCURACY accu, AR_TYPE artype ); AbstractAccess( const Symbol & sym, const List<AccessDimension> & dims, Expression * start, AbstractAccess * model_aa ); AbstractAccess( const AbstractAccess & other ); ~AbstractAccess( ); Symbol & symbol( ) const; ///< Return the symbol whose accesses are represented virtual Listable *listable_clone() const; virtual AbstractAccess *clone() const; void relink_eptrs( ProgramUnit & p ); int byte_size( ); ///< Size of one element in bytes void byte_size(int bytes); ///< Set byte size void convert_size(int new_size); ///< Convert the descriptor to a new (smaller) size ///< void range_dict ( StmtRanges * rd ); // Insert the range dictionary ///< StmtRanges & range_dict( ); // Return a reference to the range dictionary ///< void create_range_dict ( RangeAccessor & r_acc ); ///< create _range_dict from the ranges in the RangeAccessor int sort_add_dim(AccessDimension * newdim, RangeAccessor & range_acc); ///< Add newdim in its sorted position bool coalesce(); ///< Attempt to do the coalesceing operation on the object bool try_coalescing(RangeAccessor & range_acc, AccessDimension & dim_lo, int lodim, AccessDimension & dim_hi, int hidim, UGraphIterator & ugi); ///< try coalescing on two specific dimensions. Expression * correctness( ); ///< Return the correctness condition void correctness(Expression * e ); ///< Set the correctness condition bool exec_predicate_exists( ) const; ///< Return whether there is an execution predicate bool exec_predicate_true( ) const; ///< Return "true" if predicate does not exist, or exists and is ".TRUE.". bool exec_predicate_false( ) const; ///< Return "true" if the predicate exists and is ".FALSE.". int exec_predicate( ); ///< Return the execution predicate void exec_predicate( int pred ); ///< Set the execution predicate void accuracy( ACCURACY accu ); ACCURACY accuracy ( ) const; void add_actual ( Statement *stmt, Expression * expr ); ///< Takes possession of the expression Expression & actual_guarded ( ) const; void remove_actual ( ); ///< delete the actual expression ( to regain space ) Boolean actual_exists ( ) const; Statement * actual_stmt() const; ///< return _actual_stmt int number_of_dimensions( ) const; ///< Number of dimensions in access ///< (number_of_dimension_objects minus zero-stride dims) void check_sort( ); ///< Check the sorting of dimensions. Set _imprecise_sorting. void add_dimension( const AccessDimension * dim ); void add_dimension( const AccessDimension * dim, int which_dim ); ///< add a new dimension, given by dim void del_dimension( int which_dim ); ///< Delete the indicated dimension int nesting_level(); ///< Return nesting level void nesting_level( int level ); ///< Set nesting level void inc_nesting( ); ///< Increment nesting level ///< RefList<AbstractAccess> & outer( ); // Return list of outer pointers ///< RefList<AbstractAccess> & inner( ); // Return list of pointer to next-inner summaries ///< compute a new dimension holding at a point in the program, ///< using expressions as from a DO statement: ///< index = lo, hi, by int compute_new_dimension( ProgramUnit & pgm, Statement & stmt, Symbol & index, Expression & lo, Expression & hi, Expression & by); ///< remove the current object from the inner/outer chain and replace with the given object AccessDimension & dimension( int i ); Iterator<AccessDimension> iter_dims( ); Boolean start_exists( ) const; void start( Expression * start ); Expression & start_guarded( ) const; Expression * lastoffset( ) const; Statement * summarized_to(); ///< Retrieve attached statement void summarized_to( Statement * stmt ); ///< Set attached statement ProgramUnit * pgm_summarized_to(); ///< Retrieve attached statement void pgm_summarized_to( ProgramUnit * stmt ); ///< Set attached statement void check_access_patterns( ); ///< Determine whether the access ///< is triangular or subscripted-subscript ///< interprocedurally void mark_visited( ); ///< Mark object visited during traversal bool was_visited( ); ///< Return whether visited void mark_imprecise( ); ///< Mark that dimension sorting was not precise void mark_precise( ); ///< Mark that dimension sorting was precise bool is_imprecise( ); ///< Return whether dim sorting was precise void mark_diagonal( ); ///< Mark object diagonal void mark_not_diagonal( ); ///< Mark object not diagonal bool is_diagonal( ); ///< Return true or false,depending void mark_triangular( ); ///< Mark object triangular void mark_not_triangular( ); ///< Mark object not triangular bool is_triangular( ); ///< Return true or false,depending ///< on _triangular void mark_subsub( ); ///< Mark subscripted subscript bool is_subsub( ); ///< Return true or false depending ///< on _subsub void mark_nonaffine( ); ///< Mark non-affine bool is_nonaffine( ); ///< Return true or false depending ///< on _nonaffine void monoton( AR_MONOTON mono ); ///< Set monotonicity AR_MONOTON monoton( ); ///< Return monotonicity void reduct_op( RED_OP op ); ///< Set the reduction operator RED_OP reduct_op( ); ///< Get the reduction operator AbstractAccess * remap_interface_vars(InlineObject * inline_object, Statement & stmt, const Symbol & sym, REF_TYPE ref, int exec_pred=-1) const; bool read_only(); ///< Is the region read-only? bool write_first(); ///< Was the whole region written first before reading? bool approximate(); ///< Is this an approximate LMAD? void set_approximate(); ///< Mark this LMAD as approximate. int no_overlap(); ///< Do different iterations of the loop where this ///< access region is attached cause overlapping access? bool poss_reduct(); ///< Is this a possible reduction? bool poss_induct(); ///< Is this a possible induction? void read_only (bool val); ///< Set the read_only flag void write_first(bool val); ///< Set the write_first flag void no_overlap (bool val); ///< Set the no_overlap flag void no_overlap (int val); ///< Set the no_overlap flag void poss_reduct(bool val); ///< Set the possible_reduction flag void poss_induct(bool val); ///< Set the possible_induction flag void set_check_overlap( int which_dim, bool value ); ///< Set the overlap on the given dimension void calc_overlap (int which_dim); ///< Calculate and set the overlap value void translate_GSA_symbols( TranslateObject * tobj ); ///< Translate all GSA symbols in the descriptor's expressions to their non-GSA form ///< void store_traversal (RefList<AbstractAccess> & ard_list) const; ///< Add ARDs representing a traversal of inner links, starting at this node, to the list ///< Functions for matching all or parts of Access Regions bool match( AbstractAccess * aa ); bool match_by_dims( AbstractAccess * aa ); int match_dims( AbstractAccess * aa ); int match_dims_stride( AbstractAccess * aa ); bool match_by_strides( AbstractAccess * aa ); bool match_by_dims_except_1( AbstractAccess * aa ); bool match_by_start_dims_except_1( AbstractAccess * aa ); ///< This one is to satisfy Listable virtual void print(ostream & o) const; friend ostream & operator << (ostream & o, const AbstractAccess & aa); }; inline Expression * AbstractAccess::correctness( ) { return _correctness; } inline void AbstractAccess::mark_imprecise( ) { _imprecise_sorting = true; } inline void AbstractAccess::mark_precise( ) { _imprecise_sorting = false; } inline bool AbstractAccess::is_imprecise( ) { return _imprecise_sorting; } inline void AbstractAccess::mark_subsub( ) { _subsub = 1; } inline bool AbstractAccess::is_subsub( ) { if (_subsub) { return true; } else { return false; } } inline void AbstractAccess::mark_nonaffine( ) { _nonaffine = 1; } inline bool AbstractAccess::is_nonaffine( ) { if (_nonaffine) { return true; } else { return false; } } inline void AbstractAccess::mark_triangular( ) { _triangular = 1; } inline void AbstractAccess::mark_not_triangular( ) { _triangular = 0; } inline bool AbstractAccess::is_triangular( ) { if (_triangular) { return true; } else { return false; } } inline void AbstractAccess::mark_visited( ) { _visited = 1; } inline bool AbstractAccess::was_visited( ) { if (_visited) { return true; } else { return false; } } inline void AbstractAccess::mark_diagonal( ) { _diagonal = 1; } inline void AbstractAccess::mark_not_diagonal( ) { _diagonal = 0; } inline bool AbstractAccess::is_diagonal( ) { if (_diagonal) { return true; } else { return false; } } inline void AbstractAccess::monoton( AR_MONOTON mono ) { _monoton = mono; } inline AR_MONOTON AbstractAccess::monoton( ) { return (AR_MONOTON) _monoton; } inline bool AbstractAccess:: read_only() { return (_read_only == 1); } inline void AbstractAccess:: set_approximate() { _approximate = true; } inline bool AbstractAccess:: approximate() { return _approximate; } inline bool AbstractAccess:: write_first() { return (_write_first == 1); } inline int AbstractAccess:: no_overlap() { return _no_overlap; } inline void AbstractAccess:: read_only(bool val) { _read_only = val; } inline void AbstractAccess:: write_first(bool val) { _write_first = val; } inline void AbstractAccess:: no_overlap(bool val) { if (val) { _no_overlap = 1; } else { _no_overlap = 0; } } inline void AbstractAccess:: no_overlap(int val) { _no_overlap = val; } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:35 2005