void
Compile_BuildVarsBdd(
)
- This function creates the ADD variables needed
to build the automaton. If an input order file is given as option,
then the ordering of variables is read from it, else the order in
which the variables appear in a depth first traversal of the
hierarchy is used. The symbolic name of the variable is stored in an
array in a position corresponding to the first index of the boolean
variable created to encode it. The boolean variables needed to
encode a scalar symbolic variable are grouped together, so that the
ordering methods do not modify the internal order of them. If the
input order file contains a subset of the variables of the model,
than the variables not specified in the ordering file are created at
the end of the given ordering following the order in which they
appear in a depth first traversal of the hierarchy. If the input
ordering file is a superset of the variables declared in the model,
than the variables not appearing in the model are discarded.
- Side Effects state_variables_add next_state_variables_add
input_vars_add num_of_state_variables are modified.
- See Also
Compile_EncodeVar
Compile_ReadOrder
dd_new_var_block
void
Compile_CheckProgram(
node_ptr procs,
node_ptr spec_expr,
node_ptr ltlspec_expr,
node_ptr invar_expr,
node_ptr fair_expr
)
- The main routine performing all the
check on the read model.
First it loops on the body of processes to verify that there are no
multiple assignments and circular definitions.
Then performs circularity checks on the list of SPECS,
LTL SPECS, INVARIANT SPECS, FAIRNESS constraints.
The last operation performed consists in detecting multiple
assignments between different modules.
void
Compile_CompileFrame(
)
- Computes the ADD representing what does not
change between two consecutive states. i.e. it computes the frame
axioms. It loops over the state variables. For each variable
vname it consider the ADD Q stored in
frame_hash, which is an disjunction of all the processes in
whose body occurs next(vname) := ... and computes the ADD
!Q -> (vname' = vname), which is conjoined with
frame_add.
The result is stored in the global variable frame_add.
- See Also
frame_hash
void
Compile_CompileInit(
node_ptr init_expr,
node_ptr procs
)
- This function evaluates all the init statements
listed in init_expr, then evaluates all the init()
assignments in the list of processes procs. Moreover the
number of states and the number of BDD nodes of the global initial
set are printed out.
- Side Effects The result is stored in the BDD init_bdd
void
Compile_CompileModelConj(
node_ptr trans_expr,
node_ptr invar_expr,
node_ptr procs,
add_ptr assumption
)
- This function builds the BDD representing the
implicitly conjoined transition relation. The third argument (that's
"assumption") is the set of states to which the transition relation
has to be restricted to.
- See Also
Compile_CompileModelDisj
Compile_CompileModelMono
Compile_CompileModelIwls95
void
Compile_CompileModelDisj(
node_ptr trans_expr,
node_ptr invar_expr,
node_ptr procs_expr,
add_ptr assumption
)
- This function takes as input a list of processes.
For each process a partition is performed and the implicitly disjoined
transition relation is computed.
- Side Effects dp_trans_add is computed.
- See Also
Compile_CompileModel
Compile_CompileModelConj
Compile_CompileModeliwls95
void
Compile_CompileModelIwls95(
node_ptr trans_expr,
node_ptr invar_expr,
node_ptr procs,
add_ptr assumption
)
- Computes an implicitly conjoined transition
relation, in which clusters are ordered accordingly the heuristic
defined in IWLS95.
First computes the BDD representing the transition relation of the
next function of each scalar variable (next(x) := expr
). This initializes the set of clusters.
Then, the list of clusters is ordered, and if necesessary recombine
clusters to obtain a small number of clusters whose size in BDD
nodes is smaller than a given threshold. Then clusters are ordered
again.
- See Also
Compile_CompileModel
Compile_CompileModelConj
Compile_CompileModelDisj
void
Compile_CompileModel(
node_ptr trans_expr,
node_ptr invar_expr,
node_ptr procs,
add_ptr assumption
)
- Builds the the transition relation of the model,
accordingly with the partition method specified in the options.
- See Also
Compile_CompileModelConj
Compile_CompileModelDisj
Compile_CompileModelIwls95
void
Compile_EncodeVarsInit(
)
- Initializes the data structure relative to BDD
variables, i.e. the array used to store correspondence between
variable names and bdd variables, and the array used to shift
forward and backward during image computation.
add_ptr
Compile_EncodeVar(
node_ptr name,
node_ptr range,
int is_input
)
- This function encodes the variable name,
whose range is range, into BDD variables. The boolean
variables created are grouped together, in such a way that the BDD
dynamic reordering consider them as a single block.
- See Also
CompileEncodeVarRecur
void
Compile_End(
)
- Shut down the compile package
void
Compile_FlattenHierarchy(
node_ptr root_name, the ATOM
representing the module at the top of the hierarchy.
node_ptr name, the name of the module at the top of the hierarchy.
node_ptr * trans, the list of TRANS actually recognized
node_ptr * init, the list of INIT actually recognized
node_ptr * invar, the list of INVAR actually recognized
node_ptr * spec, the list of SPEC actually recognized
node_ptr * ltl_spec, the list of LTLSPEC actually recognized
node_ptr * invar_spec, the list of INVARSPEC actually recognized
node_ptr * fair, the list of FAIR actually recognized
node_ptr * assign, the list of ASSIGN actually recognized
node_ptr * procs, the list of processes actually recognized
node_ptr actual the actual module arguments
)
- Traverses the module hierarchy and extracts the
information needed to compile the automaton. The hierarchy of modules
is flattened, the variables are contextualized, the various parts of
the model read in are extracted (i.e. the formulae to be verified,
the initial expressions, ...)...
Notice that this function only manage s_expr and not ADD or BDD.
- Side Effects None
node_ptr
Compile_GetOrdering(
)
- It returns the list of variables corresponding
to the current order of variables in the system.
void
Compile_Init(
)
- Initializes the compile package.
node_ptr
Compile_ReadOrder(
const char * input_order_file
)
- This function reads from a file the variable
order to be used in the system. The grammar of the order file is as
follows:
orderfile ::= variable NL
variable ::= complex_atom
complex_atom ::= simple_atom | simple_atom DOT complex_atom
simple_atom ::= atom
Where NL is a new line, and DOT is the period character.
- See Also
write_order
void
Compile_WriteOrder(
const char * output_order_file_name,
int force
)
- This function writes the variable order
currently in use in the system in the specified output file. If the
option "-reorder" has been used then, then this function exits (if
the batch interaction mode is used). The file generated as output
can be used as input order file for next computations.
- See Also
Compile_ReadOrder