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

Last updated on 990908 16h51