static void
init_model(char *file)
{
Warning(info, "opening %s", file);
model = GBcreateBase();
GBsetChunkMap (model, HREgreyboxTableFactory());
HREbarrier(HREglobal());
GBloadFile(model, file, &model);
HREbarrier(HREglobal());
if (HREme(HREglobal())==0 && !PINS_USE_GUARDS && no_soundness_check) {
Abort("Option --no-soundness-check is incompatible with --pins-guards=false");
}
if (HREme(HREglobal())==0 && log_active(infoLong) && !no_matrix) {
fprintf(stderr, "Dependency Matrix:\n");
GBprintDependencyMatrixCombined(stderr, model);
}
ltstype = GBgetLTStype(model);
N = lts_type_get_state_length(ltstype);
eLbls = lts_type_get_edge_label_count(ltstype);
sLbls = GBgetStateLabelInfo(model) == NULL ? 0 : dm_nrows(GBgetStateLabelInfo(model));
nGrps = dm_nrows(GBgetDMInfo(model));
max_sat_levels = (N / sat_granularity) + 1;
if (PINS_USE_GUARDS) {
nGuards = GBgetStateLabelGroupInfo(model, GB_SL_GUARDS)->count;
if (HREme(HREglobal())==0) {
Warning(info, "state vector length is %d; there are %d groups and %d guards", N, nGrps, nGuards);
}
} else {
if (HREme(HREglobal())==0) {
Warning(info, "state vector length is %d; there are %d groups", N, nGrps);
}
}
int id=GBgetMatrixID(model,"inhibit");
if (id>=0){
inhibit_matrix=GBgetMatrix(model,id);
if (HREme(HREglobal())==0) {
Warning(infoLong,"inhibit matrix is:");
if (log_active(infoLong)) dm_print(stderr,inhibit_matrix);
}
}
id = GBgetMatrixID(model,LTSMIN_EDGE_TYPE_ACTION_CLASS);
if (id>=0){
class_matrix=GBgetMatrix(model,id);
if (HREme(HREglobal())==0) {
Warning(infoLong,"inhibit class matrix is:");
if (log_active(infoLong)) dm_print(stderr,class_matrix);
}
}
HREbarrier(HREglobal());
}
ProBInitialResponse
prob_init(prob_client_t pc, int is_por)
{
Debugf("initializing ProB Zocket\n")
zmsg_t *request = zmsg_new();
zmsg_addstr(request, "init");
zmsg_addstrf(request, "%d", pc->id_count);
zmsg_addstrf(request, "%d", is_por);
Debugf("sending message with length %zu, contents are:\n", zmsg_content_size(request));
#ifdef LTSMIN_DEBUG
if (log_active(debug)) zmsg_print(request);
#endif
if (zmsg_send(&request, pc->zocket) != 0) Abort("Could not send message");
zmsg_destroy(&request);
zmsg_t *response = zmsg_recv(pc->zocket);
if (response == NULL) Abort("Did not receive valid response");
Debugf("received message with length %zu, contents are:\n", zmsg_content_size(response));
#ifdef LTSMIN_DEBUG
if (log_active(debug)) zmsg_print(response);
#endif
ProBInitialResponse resp = prob_get_init_response(response);
if (zmsg_size(response) != 0) Abort("Did not receive valid reponse size");
// puts("transition groups:");
// print_chunk_array(resp.transition_groups);
// puts("variables");
// print_chunk_array(resp.variables);
// for (size_t i = 0; i < resp.variables.size; i++) {
// printf("%s (%s)\n", resp.variables.chunks[i].data, resp.variable_types.chunks[i].data);
// }
// puts("state labels");
// print_chunk_array(resp.state_labels);
//
// puts("May Write Matrix:");
// print_matrix(resp.may_write);
// puts("Must Write Matrix:");
// print_matrix(resp.must_write);
// puts("Reads Action Matrix:");
// print_matrix(resp.reads_action);
// puts("Reads Guard Matrix:");
// print_matrix(resp.reads_guard);
zmsg_destroy(&response);
return resp;
}
void
cndfs_reduce (run_t *run, wctx_t *ctx)
{
if (run->reduced == NULL) {
run->reduced = RTmallocZero (sizeof (cndfs_reduced_t));
cndfs_reduced_t *reduced = (cndfs_reduced_t *) run->reduced;
reduced->waittime = 0;
}
cndfs_reduced_t *reduced = (cndfs_reduced_t *) run->reduced;
cndfs_alg_local_t *cloc = (cndfs_alg_local_t *) ctx->local;
float waittime = RTrealTime(cloc->timer);
reduced->waittime += waittime;
reduced->rec += cloc->counters.rec;
reduced->max_load += fset_max_load (cloc->pink);
ndfs_reduce (run, ctx);
if (log_active(infoLong)) {
fset_print_statistics (cloc->pink, "Pink stack set:");
}
if (run->shared->rec != NULL) {
alg_global_t *sm = ctx->global;
alg_reduce (run->shared->rec, sm->rec);
}
}
void
ndfs_reduce (run_t *run, wctx_t *ctx)
{
if (run->reduced == NULL) {
run->reduced = RTmallocZero (sizeof (alg_reduced_t));
}
alg_reduced_t *reduced = run->reduced;
counter_t *blue = &ctx->local->counters;
counter_t *red = &ctx->local->red;
work_counter_t *blue_work = ctx->counters;
work_counter_t *red_work = &ctx->local->red_work;
add_results (&reduced->blue, blue);
add_results (&reduced->red, red);
work_add_results (&reduced->red_work, red_work);
// publish local memory statistics for run class
run->total.local_states += blue_work->level_max + red_work->level_max;
if (W >= 4 || !log_active(infoLong)) return;
// print some local info
float runtime = RTrealTime(ctx->timer);
Warning (info, "Nested depth-first search worker ran %.3f sec", runtime);
work_report ("[Blue]", blue_work);
work_report ("[Red ]", red_work);
}
static ProBState *
prob_next_x(prob_client_t pc, ProBState s, char *transitiongroup, int *size, char *header) {
zmsg_t *request = zmsg_new();
zmsg_addstr(request, header);
zmsg_addstrf(request, "%d", pc->id_count);
zmsg_addstr(request, transitiongroup);
prob_put_state(request, s);
Debugf("requesting next-state, contents:\n");
#ifdef LTSMIN_DEBUG
if (log_active(debug)) zmsg_print(request);
#endif
zmsg_send(&request, pc->zocket);
zmsg_destroy(&request);
zmsg_t *response = zmsg_recv(pc->zocket);
Debugf("response for next-state, contents:\n");
#ifdef LTSMIN_DEBUG
if (log_active(debug)) zmsg_print(response);
#endif
drop_frame(response);
drop_frame(response);
char *nr_of_states_s = zmsg_popstr(response);
sscanf(nr_of_states_s, "%d", size);
RTfree(nr_of_states_s);
ProBState *successors = RTmalloc(sizeof(ProBState) * (*size));
int i;
for (i = 0; i < (*size); i++) {
successors[i] = prob_get_state(response);
}
zmsg_destroy(&response);
return successors;
}
/**
* \brief Creates a symbolic parity game from the generated LTS.
*/
parity_game *
compute_symbolic_parity_game(vset_t visited, int *src)
{
Print(infoShort, "Computing symbolic parity game.");
debug_output_enabled = true;
// num_vars and player have been pre-computed by init_pbes.
parity_game* g = spg_create(domain, N, nGrps, min_priority, max_priority);
for(int i=0; i < N; i++)
{
g->src[i] = src[i];
}
vset_copy(g->v, visited);
for(size_t i = 0; i < num_vars; i++)
{
// players
Print(infoLong, "Adding nodes for var %zu (player %d).", i, player[i]);
add_variable_subset(g->v_player[player[i]], g->v, g->domain, i);
// priorities
add_variable_subset(g->v_priority[priority[i]], g->v, g->domain, i);
}
if (log_active(infoLong))
{
for(int p = 0; p < 2; p++)
{
long n_count;
double elem_count;
vset_count(g->v_player[p], &n_count, &elem_count);
Print(infoLong, "player %d: %ld nodes, %.*g elements.", p, n_count, DBL_DIG, elem_count);
}
for(int p = min_priority; p <= max_priority; p++)
{
long n_count;
double elem_count;
vset_count(g->v_priority[p], &n_count, &elem_count);
Print(infoLong, "priority %d: %ld nodes, %.*g elements.", p, n_count, DBL_DIG, elem_count);
}
}
for(int i = 0; i < nGrps; i++)
{
g->e[i] = group_next[i];
}
return g;
}
/**
* \brief Computes the subset of v that belongs to player <tt>player</tt>.
* \param vars the indices of variables of player <tt>player</tt>.
*/
static inline void
add_variable_subset(vset_t dst, vset_t src, vdom_t domain, int var_index)
{
//Warning(info, "add_variable_subset: var_index=%d", var_index);
int p_len = 1;
int proj[1] = {var_pos}; // position 0 encodes the variable
int match[1] = {var_index}; // the variable
vset_t u = vset_create(domain, -1, NULL);
vset_copy_match_proj(u, src, p_len, proj, variable_projection, match);
if (debug_output_enabled && log_active(infoLong))
{
double e_count;
vset_count(u, NULL, &e_count);
if (e_count > 0) Print(infoLong, "add_variable_subset: %d: %.*g states", var_index, DBL_DIG, e_count);
}
vset_union(dst, u);
vset_destroy(u);
}
void
final_stat_reporting(vset_t visited)
{
RTprintTimer(info, reach_timer, "reachability took");
if (dlk_detect) Warning(info, "No deadlocks found");
if (act_detect != NULL) {
Warning(info, "%d different actions with prefix \"%s\" are found", ErrorActions, act_detect);
}
long n_count;
Print(infoShort, "counting visited states...");
rt_timer_t t = RTcreateTimer();
RTstartTimer(t);
char states[128];
long double e_count;
int digs = vset_count_fn(visited, &n_count, &e_count);
snprintf(states, 128, "%.*Lg", digs, e_count);
RTstopTimer(t);
RTprintTimer(infoShort, t, "counting took");
RTresetTimer(t);
int is_precise = strstr(states, "e") == NULL && strstr(states, "inf") == NULL;
Print(infoShort, "state space has%s %s states, %ld nodes", precise && is_precise ? " precisely" : "", states, n_count);
if (!is_precise && precise) {
if (vdom_supports_precise_counting(domain)) {
Print(infoShort, "counting visited states precisely...");
RTstartTimer(t);
bn_int_t e_count;
vset_count_precise(visited, n_count, &e_count);
RTstopTimer(t);
RTprintTimer(infoShort, t, "counting took");
size_t len = bn_strlen(&e_count);
char e_str[len];
bn_int2string(e_str, len, &e_count);
bn_clear(&e_count);
Print(infoShort, "state space has precisely %s states (%zu digits)", e_str, strlen(e_str));
} else Warning(info, "vset implementation does not support precise counting");
}
RTdeleteTimer(t);
if (log_active (infoLong) || peak_nodes) {
log_t l;
if (peak_nodes) l = info;
else l = infoLong;
if (max_lev_count == 0) {
Print(l, "( %ld final BDD nodes; %ld peak nodes )", n_count, max_vis_count);
} else {
Print(l,
"( %ld final BDD nodes; %ld peak nodes; %ld peak nodes per level )",
n_count, max_vis_count, max_lev_count);
}
if (log_active (debug)) {
Debug("( peak transition cache: %ld nodes; peak group explored: " "%ld nodes )\n",
max_trans_count, max_grp_count);
}
}
}
void
stats_and_progress_report(vset_t current, vset_t visited, int level)
{
long n_count;
long double e_count;
if (sat_strategy == NO_SAT || log_active (infoLong)) {
Print(infoShort, "level %d is finished", level);
}
if (log_active (infoLong) || peak_nodes) {
if (current != NULL) {
int digs = vset_count_fn (current, &n_count, &e_count);
Print(infoLong, "level %d has %.*Lg states ( %ld nodes )", level, digs, e_count, n_count);
if (n_count > max_lev_count) max_lev_count = n_count;
}
int digs = vset_count_fn (visited, &n_count, &e_count);
Print(infoLong, "visited %d has %.*Lg states ( %ld nodes )", level, digs, e_count, n_count);
if (n_count > max_vis_count) max_vis_count = n_count;
if (log_active (debug)) {
Debug("transition caches ( grp nds elts ):");
for (int i = 0; i < nGrps; i++) {
vrel_count(group_next[i], &n_count, NULL);
Debug("( %d %ld ) ", i, n_count);
if (n_count > max_trans_count) max_trans_count = n_count;
}
Debug("\ngroup explored ( grp nds elts ): ");
for (int i = 0; i < nGrps; i++) {
vset_count(group_explored[i], &n_count, NULL);
Debug("( %d %ld) ", i, n_count);
if (n_count > max_grp_count) max_grp_count = n_count;
}
}
}
if (dot_dir != NULL) {
FILE *fp;
char *file;
file = "%s/current-l%d.dot";
char fcbuf[snprintf(NULL, 0, file, dot_dir, level)];
sprintf(fcbuf, file, dot_dir, level);
fp = fopen(fcbuf, "w+");
vset_dot(fp, current);
fclose(fp);
file = "%s/visited-l%d.dot";
char fvbuf[snprintf(NULL, 0, file, dot_dir, level)];
sprintf(fvbuf, file, dot_dir, level);
fp = fopen(fvbuf, "w+");
vset_dot(fp, visited);
fclose(fp);
for (int i = 0; i < nGrps; i++) {
file = "%s/group_next-l%d-k%d.dot";
char fgbuf[snprintf(NULL, 0, file, dot_dir, level, i)];
sprintf(fgbuf, file, dot_dir, level, i);
fp = fopen(fgbuf, "w+");
vrel_dot(fp, group_next[i]);
fclose(fp);
}
for (int g = 0; g < nGuards && PINS_USE_GUARDS; g++) {
file = "%s/guard_false-l%d-g%d.dot";
char fgfbuf[snprintf(NULL, 0, file, dot_dir, level, g)];
sprintf(fgfbuf, file, dot_dir, level, g);
fp = fopen(fgfbuf, "w+");
vset_dot(fp, label_false[g]);
fclose(fp);
file = "%s/guard_true-l%d-g%d.dot";
char fgtbuf[snprintf(NULL, 0, file, dot_dir, level, g)];
sprintf(fgtbuf, file, dot_dir, level, g);
fp = fopen(fgtbuf, "w+");
vset_dot(fp, label_true[g]);
fclose(fp);
}
}
}
permute_t *
permute_create (permutation_perm_t permutation, model_t model, alg_state_seen_f ssf,
int worker_index, void *run_ctx)
{
permute_t *perm = RTalign (CACHE_LINE_SIZE, sizeof(permute_t));
perm->todos = RTalign (CACHE_LINE_SIZE, sizeof(permute_todo_t[K+TODO_MAX]));
perm->tosort = RTalign (CACHE_LINE_SIZE, sizeof(int[K+TODO_MAX]));
perm->shift = ((double)K)/W;
perm->shiftorder = (1UL<<dbs_size) / W * worker_index;
perm->start_group = perm->shift * worker_index;
perm->model = model;
perm->state_seen = ssf;
perm->por_proviso = 1;
perm->permutation = permutation;
perm->run_ctx = run_ctx;
perm->next = state_info_create ();
if (Perm_Otf == perm->permutation)
perm->pad = RTalign (CACHE_LINE_SIZE, sizeof(int[K+TODO_MAX]));
if (Perm_Random == perm->permutation) {
perm->rand = RTalignZero (CACHE_LINE_SIZE, sizeof(int*[K+TODO_MAX]));
for (size_t i = 1; i < K+TODO_MAX; i++) {
perm->rand[i] = RTalign (CACHE_LINE_SIZE, sizeof(int[ i ]));
randperm (perm->rand[i], i, perm->shiftorder);
}
}
if (Perm_RR == perm->permutation) {
perm->rand = RTalignZero (CACHE_LINE_SIZE, sizeof(int*));
perm->rand[0] = RTalign (CACHE_LINE_SIZE, sizeof(int[1<<RR_ARRAY_SIZE]));
srandom (time(NULL) + 9876432*worker_index);
for (int i =0; i < (1<<RR_ARRAY_SIZE); i++)
perm->rand[0][i] = random();
}
if (Perm_SR == perm->permutation || Perm_Dynamic == perm->permutation) {
perm->rand = RTalignZero (CACHE_LINE_SIZE, sizeof(int*));
perm->rand[0] = RTalign (CACHE_LINE_SIZE, sizeof(int[K+TODO_MAX]));
randperm (perm->rand[0], K+TODO_MAX, (time(NULL) + 9876*worker_index));
}
perm->labels = lts_type_get_edge_label_count (GBgetLTStype(model));
for (size_t i = 0; i < K+TODO_MAX; i++) {
if (act_detect || files[1] || (PINS_BUCHI_TYPE == PINS_BUCHI_TYPE_TGBA)) {
perm->todos[i].ti.labels = RTmalloc (sizeof(int*[perm->labels]));
} else {
perm->todos[i].ti.labels = NULL;
}
}
perm->class_label = lts_type_find_edge_label (GBgetLTStype(model),LTSMIN_EDGE_TYPE_ACTION_CLASS);
if (inhibit){
int id=GBgetMatrixID(model,"inhibit");
if (id>=0){
perm->inhibit_matrix = GBgetMatrix (model, id);
Warning(infoLong,"inhibit matrix is:");
if (log_active(infoLong)) dm_print (stderr, perm->inhibit_matrix);
perm->inhibited_by = (ci_list **)dm_cols_to_idx_table (perm->inhibit_matrix);
} else {
Warning(infoLong,"no inhibit matrix");
}
id = GBgetMatrixID(model,LTSMIN_EDGE_TYPE_ACTION_CLASS);
if (id>=0){
perm->class_matrix=GBgetMatrix(model,id);
Warning(infoLong,"inhibit class matrix is:");
if (log_active(infoLong)) dm_print(stderr,perm->class_matrix);
} else {
Warning(infoLong,"no inhibit class matrix");
}
if (perm->class_label>=0) {
Warning(infoLong,"inhibit class label is %d",perm->class_label);
} else {
Warning(infoLong,"no inhibit class label");
}
}
if (PINS_POR) por_set_find_state (state_find, perm);
return perm;
}