static void
output_init(FILE *tbl_file)
{
int state[N];
GBgetInitialState(model, state);
fprintf(tbl_file, "begin state\n");
for (int i = 0; i < N; i++) {
fprint_ltsmin_ident(tbl_file, lts_type_get_state_name(ltstype, i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_type(ltstype, i));
fprintf(tbl_file, (i == (N - 1))?"\n":" ");
}
fprintf(tbl_file,"end state\n");
fprintf(tbl_file,"begin edge\n");
for(int i = 0; i < eLbls; i++) {
fprint_ltsmin_ident(tbl_file, lts_type_get_edge_label_name(ltstype, i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_edge_label_type(ltstype, i));
fprintf(tbl_file, (i == (eLbls - 1))?"\n":" ");
}
fprintf(tbl_file, "end edge\n");
fprintf(tbl_file, "begin init\n");
for(int i = 0; i < N; i++)
fprintf(tbl_file, "%d%s", state[i], (i == (N - 1))?"\n":" ");
fprintf(tbl_file,"end init\n");
}
static int
type_max (check_ctx_t *ctx, int idx)
{
model_t model = ctx->parent;
lts_type_t ltstype = GBgetLTStype (model);
int typeno = lts_type_get_state_typeno (ltstype, idx);
int c;
switch (lts_type_get_format (ltstype, typeno))
{
case LTStypeDirect:
GBgetInitialState (model, ctx->src2);
c = ctx->src2[idx];
return c == 0 ? 1 : c;
case LTStypeRange:
return lts_type_get_min (ltstype, typeno);
case LTStypeEnum:
c = pins_chunk_count (model, typeno);
HREassert (c > 0, "Empty enum table for slot: %d -- %s", idx, str_slot(ctx, NULL, idx));
return c;
case LTStypeChunk:
c = pins_chunk_count (model, typeno);
return c == 0 ? 1 : c;
case LTStypeBool:
return 1;
case LTStypeTrilean:
return 2;
case LTStypeSInt32:
return (1ULL<<31) - 1;
default: {
HREassert(false);
return -1;
}
}
}
int main(int argc, char *argv[]){
char *files[2];
RTinitPopt(&argc,&argv,options,1,2,files,NULL,"<model> [<lts>]",
"Perform an enumerative reachability analysis of <model>\n"
"Run the TorX remote procedure call protocol on <model> (--torx).\n\n"
"Options");
if (files[1]) {
Warning(info,"Writing output to %s",files[1]);
write_lts=1;
} else {
Warning(info,"No output, just counting the number of states");
write_lts=0;
}
if (application==RunTorX && write_lts) Fatal(1,error,"A TorX server does not write to a file");
Warning(info,"loading model from %s",files[0]);
model_t model=GBcreateBase();
GBsetChunkMethods(model,new_string_index,NULL,
(int2chunk_t)SIgetC,(chunk2int_t)SIputC,(get_count_t)SIgetCount);
GBloadFile(model,files[0],&model);
if (RTverbosity >=2) {
fprintf(stderr,"Dependency Matrix:\n");
GBprintDependencyMatrix(stderr,model);
}
if (matrix) {
GBprintDependencyMatrix(stdout,model);
exit(0);
}
lts_type_t ltstype=GBgetLTStype(model);
N=lts_type_get_state_length(ltstype);
edge_info_t e_info=GBgetEdgeInfo(model);
K=e_info->groups;
Warning(info,"length is %d, there are %d groups",N,K);
state_labels=lts_type_get_state_label_count(ltstype);
edge_labels=lts_type_get_edge_label_count(ltstype);
Warning(info,"There are %d state labels and %d edge labels",state_labels,edge_labels);
if (state_labels&&write_lts&&!write_state) {
Fatal(1,error,"Writing state labels, but not state vectors unsupported. "
"Writing of state vector is enabled with the option --write-state");
}
int src[N];
GBgetInitialState(model,src);
Warning(info,"got initial state");
int level=0;
switch(application){
case ReachVset:
domain=vdom_create_default(N);
visited_set=vset_create(domain,0,NULL);
next_set=vset_create(domain,0,NULL);
if (write_lts){
output=lts_output_open(files[1],model,1,0,1,"viv",NULL);
lts_output_set_root_vec(output,(uint32_t*)src);
lts_output_set_root_idx(output,0,0);
output_handle=lts_output_begin(output,0,0,0);
}
vset_add(visited_set,src);
vset_add(next_set,src);
vset_t current_set=vset_create(domain,0,NULL);
while (!vset_is_empty(next_set)){
if (RTverbosity >= 1)
Warning(info,"level %d has %d states, explored %d states %d trans",
level,(visited-explored),explored,trans);
level++;
vset_copy(current_set,next_set);
vset_clear(next_set);
vset_enum(current_set,explore_state_vector,model);
}
long long size;
long nodes;
vset_count(visited_set,&nodes,&size);
Warning(info,"%lld reachable states represented symbolically with %ld nodes",size,nodes);
break;
case ReachTreeDBS:
dbs=TreeDBScreate(N);
if(TreeFold(dbs,src)!=0){
Fatal(1,error,"expected 0");
}
if (write_lts){
output=lts_output_open(files[1],model,1,0,1,write_state?"vsi":"-ii",NULL);
if (write_state) lts_output_set_root_vec(output,(uint32_t*)src);
lts_output_set_root_idx(output,0,0);
output_handle=lts_output_begin(output,0,0,0);
}
int limit=visited;
while(explored<visited){
if (limit==explored){
if (RTverbosity >= 1)
Warning(info,"level %d has %d states, explored %d states %d trans",
level,(visited-explored),explored,trans);
limit=visited;
level++;
}
TreeUnfold(dbs,explored,src);
explore_state_index(model,explored,src);
}
break;
case RunTorX:
{
torx_struct_t context = { model, ltstype };
torx_ui(&context);
return 0;
}
}
if (write_lts){
lts_output_end(output,output_handle);
Warning(info,"finishing the writing");
lts_output_close(&output);
Warning(info,"state space has %d levels %d states %d transitions",level,visited,trans);
} else {
printf("state space has %d levels %d states %d transitions\n",level,visited,trans);
}
return 0;
}
void CAESAR_START_STATE(CAESAR_TYPE_STATE s) {
GBgetInitialState(model,s->state);
}
static void actual_main(void *arg)
#endif
{
int argc = ((struct args_t*)arg)->argc;
char **argv = ((struct args_t*)arg)->argv;
/* initialize HRE */
HREinitBegin(argv[0]);
HREaddOptions(options,"Perform a symbolic reachability analysis of <model>\n"
"The optional output of this analysis is an ETF "
"representation of the input\n\nOptions");
lts_lib_setup(); // add options for LTS library
HREinitStart(&argc,&argv,1,2,files,"<model> [<etf>]");
/* initialize HRE on other workers */
init_hre(HREglobal());
/* check for unsupported options */
if (PINS_POR != PINS_POR_NONE) Abort("Partial-order reduction and symbolic model checking are not compatible.");
if (inhibit_matrix != NULL && sat_strategy != NO_SAT) Abort("Maximal progress is incompatibale with saturation.");
if (files[1] != NULL) {
char *ext = strrchr(files[1], '.');
if (ext == NULL || ext == files[1]) {
Abort("Output filename has no extension!");
}
if (strcasecmp(ext, ".etf") != 0) {
// not ETF
if (!(vset_default_domain == VSET_Sylvan && strcasecmp(ext, ".bdd") == 0) &&
!(vset_default_domain == VSET_LDDmc && strcasecmp(ext, ".ldd") == 0)) {
Abort("Only supported output formats are ETF, BDD (with --vset=sylvan) and LDD (with --vset=lddmc)");
}
if (PINS_USE_GUARDS) {
Abort("Exporting symbolic state space not comptabile with "
"guard-splitting");
}
}
}
#ifdef HAVE_SYLVAN
if (!USE_PARALLELISM) {
if (strategy == PAR_P) {
strategy = BFS_P;
Print(info, "Front-end not thread-safe; using --order=bfs-prev instead of --order=par-prev.");
} else if (strategy == PAR) {
strategy = BFS;
Print(info, "Front-end not thread-safe; using --order=bfs instead of --order=par.");
}
}
#endif
/* turn off Lace for now to speed up while not using parallelism */
lace_suspend();
/* initialize the model and PINS wrappers */
init_model(files[0]);
/* initialize action detection */
act_label = lts_type_find_edge_label_prefix (ltstype, LTSMIN_EDGE_TYPE_ACTION_PREFIX);
if (act_label != -1) action_typeno = lts_type_get_edge_label_typeno(ltstype, act_label);
if (act_detect != NULL) init_action_detection();
bitvector_create(&state_label_used, sLbls);
if (inv_detect != NULL) init_invariant_detection();
else if (PINS_USE_GUARDS) {
for (int i = 0; i < nGuards; i++) {
bitvector_set(&state_label_used, i);
}
}
init_maxsum(ltstype);
/* turn on Lace again (for Sylvan) */
if (vset_default_domain==VSET_Sylvan || vset_default_domain==VSET_LDDmc) {
lace_resume();
}
if (next_union) vset_next_fn = vset_next_union_src;
init_domain(VSET_IMPL_AUTOSELECT);
vset_t initial = vset_create(domain, -1, NULL);
int *src = RTmalloc (sizeof(int[N]));
GBgetInitialState(model, src);
vset_add(initial, src);
Print(infoShort, "got initial state");
/* if writing .dot files, open directory first */
if (dot_dir != NULL) {
DIR* dir = opendir(dot_dir);
if (dir) {
closedir(dir);
} else if (ENOENT == errno) {
Abort("Option 'dot-dir': directory '%s' does not exist", dot_dir);
} else {
Abort("Option 'dot-dir': failed opening directory '%s'", dot_dir);
}
}
if (vset_dir != NULL) {
DIR *dir = opendir(vset_dir);
if (dir) {
closedir(dir);
} else if (errno == ENOENT) {
Abort("Option 'save-levels': directory '%s' does not exist", vset_dir);
} else {
Abort("Option 'save-levels': failed opening directory '%s'", vset_dir);
}
}
init_mu_calculus();
/* determine if we need to generate a symbolic parity game */
#ifdef LTSMIN_PBES
bool spg = true;
#else
bool spg = GBhaveMucalc() ? true : false;
#endif
/* if spg, then initialize labeling stuff before reachability */
if (spg) {
Print(infoShort, "Generating a Symbolic Parity Game (SPG).");
init_spg(model);
}
/* create timer */
reach_timer = RTcreateTimer();
/* fix level 0 */
visited = vset_create(domain, -1, NULL);
vset_copy(visited, initial);
/* check the invariants at level 0 */
check_invariants(visited, 0);
/* run reachability */
run_reachability(visited, files[1]);
/* report states */
final_stat_reporting(visited);
/* save LTS */
if (files[1] != NULL) {
char *ext = strrchr(files[1], '.');
if (strcasecmp(ext, ".etf") == 0) {
do_output(files[1], visited);
} else {
// if not .etf, then the filename ends with .bdd or .ldd, symbolic LTS
do_dd_output (initial, visited, files[1]);
}
}
compute_maxsum(visited, domain);
CHECK_MU(visited, src);
if (max_mu_count > 0) {
Print(info, "Mu-calculus peak nodes: %ld", max_mu_count);
}
/* optionally print counts of all group_next and group_explored sets */
final_final_stats_reporting ();
if (spg) { // converting the LTS to a symbolic parity game, save and solve.
lts_to_pg_solve (visited, src);
}
#ifdef HAVE_SYLVAN
/* in case other Lace threads were still suspended... */
if (vset_default_domain!=VSET_Sylvan && vset_default_domain!=VSET_LDDmc) {
lace_resume();
} else if (SYLVAN_STATS) {
sylvan_stats_report(stderr);
}
#endif
RTfree (src);
GBExit(model);
}