Go to the first, previous, next, last section, table of contents.
fill_in_access(tree_proc * tp)
: annotates code in the given
tree_proc with dep_instr_annote
and dep_for_annote
. These
annotations store information needed by the dependence analyzer.
fill_in_access
must be run before any calls to DependenceTest
.
enum deptest_result {dt_none, dt_ok, dt_indep, dt_no_common_nest,
dt_too_messy}
: When DependenceTest
is called with a
deptest_result
pointer, the pointer will be assigned one of these
five values. dt_none
indicates that no dependence test was run.
dt_ok
means that the two array accesses are data dependent, and
the corresponding dependence vectors are returned by
DependenceTest
. Returning dt_indep
conveys that the two
array accesses are independent, and returning dt_no_common_nest
indicates the accesses have no common enclosing loop. Lastly,
dt_too_messy
suggests that the array access function was too messy,
thus beyond the scope of the dependence analyzer.
dvlist * DependenceTest(in_array *w, in_array *r, int lexpos,
deptest_result * res)
: Function DependenceTest
tests whether the
two array accesses (*w & *r)
are data dependent. In particular,
it tests whether *w
is data dependent on *r
. If *w
is indeed dependent on *r
, dt_ok
would be assigned to
*res
. Otherwise, *res
would be given a value other than
dt_ok
. See above for other deptest_result
values. When
the two accesses are data dependent, DependenceTest
returns a
list of dependence vectors. If lexpos
is set, the list of
dependence vectors would only contain lexicographically positive
dependence vectors.
dvlist * DependenceTest(in_array *w, in_array *r, deptest_result *
res)
: Calling this function is equivalent to calling
DependenceTest(in_array *w, in_array *r, int lexpos, deptest_result *
res)
with lexpos = 1
.
dvlist * DependenceTest(in_array *w, in_array *r, int lexpos)
:
Calling this function is the same as calling
DependenceTest(in_array *w, in_array *r, int lexpos,
deptest_result * res)
except no deptest_result
is returned
through the deptest_result
pointer.
dvlist * DependenceTest(in_array *w, in_array *r)
: Calling this
function is equivalent to calling DependenceTest(in_array *w,
in_array *r, int lexpos)
with lexpos = 1
.
void print_array_access(in_array * in, FILE * fs = stdout)
: print
the array access *in
to file *fs
.
class dvlist int indep(); dvlist_e *pop(); void print(FILE *);
A dvlist is used to store a list of dependence vectors. Method
indep
returns TRUE
only if the corresponding array
accesses are independent. Method pop
returns the first element
of the list of dependence vectors as a dvlist_e
. Lastly, the
print
method is provided for class dvlist
for outputing
the list to a file.
class dvlist_iter dvlist_iter(dvlist *dv); dvlist_e *step(); int is_empty()
A dvlist_iter
is an iterator for class dvlist
. Once an
iterator is created for a specific dvlist *dv
(using
dvlist_iter(dv)
), the methods step
, next
,
is_empty
, etc. can be used to look at the elements of the list
(also see documentation for glist_iter
in the SUIF Library
Reference Manual).
class dvlist_e distance_vector * dv;
Each element of a dvlist
is a dvlist_e
, and a
dvlist_e
simply contains a dependence vector represented by the
class distance_vector
.
class distance_vector distance_vector_e *pop() indep(); void print(FILE *); is_empty() int is_zero(); /* is the vector 0? */ int is_pos(); /* is first entry positive? */ int is_neg(); /* negative? */ int is_star(); /* star? */ int level(); /* what is the level of this dep? */ int size(); /* how big is the dvector? */ distance *thresh(int level); /* what is the threshold? must be # */ void negate(); /* negate all of the distances */ int first_not_eq(); /* level of the first non-= or * */ /* if all =, returns 0 */ int operator==(distance_vector &); /* if two vectors identical */ int operator!=(distance_vector &d);
A dependence vector is represented by class distance_vector
which
is a list of distance_vector_e
. The length of the vector can be
obtained by calling the method size
. The elements of the list
can be extracted from the list using the pop
method, and the
is_empty
method tests whether all the elements have been removed.
Of course, one can also instantiate an iterator for looking at the list.
Some other useful methods are: indep
returns TRUE if the
corresponding array accesses are independent, level
returns the
dependence level, first_not_eq
returns the level of the first
non-zero component, negate
simply reverses the sign of all the
components, and print
outputs the dependence vector to a file.
Operators ==
and !=
are provided for comparing dependence
vectors, and methods is_zero
, is_pos
, is_neg
,
is_star
respectively test whether the distance_vector is a zero
vector, a lexicographically positive vector, a lexicographically
negative vector, or a vector with the star direction as its first entry.
class distance_vector_e distance d; int is_zero(); };
Each element of a distance_vector
is a distance_vector_e
,
and a distance_vector_e
contains a distance, a component of a
dependence vector. A method is_zero
is provided to test whether
the distance is zero.
enum direction {d_lt=1,d_gt=2,d_eq=4,d_le=5,d_ge=6,d_lg=3,d_star=7};
Each component of a dependence vector can be summarized by one of seven
directions. d_lt
represents <
, d_gt
represents
>
, d_eq
represents =
, d_le
represents
<=
, d_ge
represents >=
, d_lg
represents
<>
and d_star
represents *
.
class distance int is_const(); int dist(); direction dir(); int is_star(); int has_eq(); void print(FILE *); int is_zero(); void negate(); /* negate the distance */ int operator ==(distance &d) int operator !=(distance &d)
Each component of a dependence vector (represented by class
distance_vector
) is a distance. An object of type distance
contains a direction, and can be obtained by calling the method
dir
. In addition, if a numeric value is known, the object also
stores the integer value. If an object of type distance
contains
an integer value, a call to is_const
would return TRUE and a call
to method dist
would return the integer value. Similarly,
methods is_zero
and is_star
test whether an object is
respectively the direction d_eq
and the direction d_star
.
Method has_eq
returns TRUE if the object contains a direction
including d_eq
, i.e. d_eq
, d_le
, d_ge
and
d_star
. Furthermore, a few helpful mthods are provided for
class distance
. For example, operators ==
and !=
are provided to compare objects of type distance
. The method
negate
is provided to negate a distance and method print
to
output the distance to a file.
Go to the first, previous, next, last section, table of contents.