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());
}
void
mark_predicate (model_t m, ltsmin_expr_t e, int *dep, ltsmin_parse_env_t env)
{
if (!e) return;
switch(e->node_type) {
case BINARY_OP:
mark_predicate(m,e->arg1,dep,env);
mark_predicate(m,e->arg2,dep,env);
break;
case UNARY_OP:
mark_predicate(m,e->arg1,dep,env);
break;
default:
switch(e->token) {
case PRED_TRUE:
case PRED_FALSE:
case PRED_NUM:
case PRED_VAR:
case PRED_CHUNK:
break;
case PRED_EQ:
mark_predicate(m,e->arg1, dep,env);
mark_predicate(m,e->arg2, dep,env);
break;
case PRED_SVAR: {
lts_type_t ltstype = GBgetLTStype(m);
int N = lts_type_get_state_length (ltstype);
if (e->idx < N) { // state variable
dep[e->idx] = 1;
} else { // state label
HREassert (e->idx < N + lts_type_get_state_label_count(ltstype));
matrix_t *sl = GBgetStateLabelInfo (m);
HREassert (N == dm_ncols(sl));
for (int i = 0; i < N; i++) {
if (dm_is_set(sl, e->idx - N, i)) dep[i] = 1;
}
}
break;
}
default:
LTSminLogExpr (error, "Unhandled predicate expression: ", e, env);
HREabort (LTSMIN_EXIT_FAILURE);
}
break;
}
}
static void
output_lbls(FILE *tbl_file, vset_t visited)
{
matrix_t *sl_info = GBgetStateLabelInfo(model);
nGuards = dm_nrows(sl_info);
if (dm_nrows(sl_info) != lts_type_get_state_label_count(ltstype))
Warning(error, "State label count mismatch!");
for (int i = 0; i < nGuards; i++){
int len = dm_ones_in_row(sl_info, i);
int used[len];
// get projection
for (int pi = 0, pk = 0; pi < dm_ncols (sl_info); pi++) {
if (dm_is_set (sl_info, i, pi))
used[pk++] = pi;
}
vset_t patterns = vset_create(domain, len, used);
map_context ctx;
vset_project(patterns, visited);
ctx.tbl_file = tbl_file;
ctx.mapno = i;
ctx.len = len;
ctx.used = used;
fprintf(tbl_file, "begin map ");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_label_name(ltstype,i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_label_type(ltstype,i));
fprintf(tbl_file,"\n");
vset_enum(patterns, enum_map, &ctx);
fprintf(tbl_file, "end map\n");
vset_destroy(patterns);
}
}
static int etf_state_short(model_t self,int label,int *state){
gb_context_t ctx=(gb_context_t)GBgetContext(self);
matrix_t *sl_info = GBgetStateLabelInfo(self);
int len=dm_ones_in_row(sl_info,label);
return ctx->label_data[label][SIlookupC(ctx->label_key_idx[label],(char*)state,len<<2)];
}
static void
init_domain(vset_implementation_t impl) {
domain = vdom_create_domain(N, impl);
for (int i = 0; i < dm_ncols(GBgetDMInfo(model)); i++) {
vdom_set_name(domain, i, lts_type_get_state_name(ltstype, i));
}
group_next = (vrel_t*)RTmalloc(nGrps * sizeof(vrel_t));
group_explored = (vset_t*)RTmalloc(nGrps * sizeof(vset_t));
group_tmp = (vset_t*)RTmalloc(nGrps * sizeof(vset_t));
r_projs = (ci_list **)RTmalloc(sizeof(ci_list *[nGrps]));
w_projs = (ci_list **)RTmalloc(sizeof(ci_list *[nGrps]));
l_projs = (ci_list **)RTmalloc(sizeof(ci_list *[sLbls]));
label_false = (vset_t*)RTmalloc(sLbls * sizeof(vset_t));
label_true = (vset_t*)RTmalloc(sLbls * sizeof(vset_t));
label_tmp = (vset_t*)RTmalloc(sLbls * sizeof(vset_t));
if (!vdom_separates_rw(domain) && !PINS_USE_GUARDS) {
read_matrix = GBgetDMInfo(model);
write_matrix = GBgetDMInfo(model);
Warning(info, "Using GBgetTransitionsShort as next-state function");
transitions_short = GBgetTransitionsShort;
} else if (!vdom_separates_rw(domain) && PINS_USE_GUARDS) {
read_matrix = GBgetMatrix(model, GBgetMatrixID(model, LTSMIN_MATRIX_ACTIONS_READS));
write_matrix = GBgetDMInfo(model);
Warning(info, "Using GBgetActionsShort as next-state function");
transitions_short = GBgetActionsShort;
} else if (vdom_separates_rw(domain) && !PINS_USE_GUARDS) {
read_matrix = GBgetDMInfoRead(model);
write_matrix = GBgetDMInfoMayWrite(model);
Warning(info, "Using GBgetTransitionsShortR2W as next-state function");
transitions_short = GBgetTransitionsShortR2W;
} else { // vdom_separates_rw(domain) && PINS_USE_GUARDS
read_matrix = GBgetMatrix(model, GBgetMatrixID(model, LTSMIN_MATRIX_ACTIONS_READS));
write_matrix = GBgetDMInfoMayWrite(model);
Warning(info, "Using GBgetActionsShortR2W as next-state function");
transitions_short = GBgetActionsShortR2W;
}
if (PINS_USE_GUARDS) {
if (no_soundness_check) {
Warning(info, "Guard-splitting: not checking soundness of the specification, this may result in an incorrect state space!");
} else {
Warning(info, "Guard-splitting: checking soundness of specification, this may be slow!");
}
}
r_projs = (ci_list **) dm_rows_to_idx_table (read_matrix);
w_projs = (ci_list **) dm_rows_to_idx_table (write_matrix);
for(int i = 0; i < nGrps; i++) {
if (HREme(HREglobal())==0)
{
if (vdom_separates_rw(domain)) {
group_next[i] = vrel_create_rw (domain, r_projs[i]->count, r_projs[i]->data, w_projs[i]->count, w_projs[i]->data);
} else {
group_next[i] = vrel_create (domain, r_projs[i]->count, r_projs[i]->data);
}
group_explored[i] = vset_create (domain, r_projs[i]->count, r_projs[i]->data);
group_tmp[i] = vset_create (domain, r_projs[i]->count, r_projs[i]->data);
if (inhibit_matrix != NULL) {
inhibit_class_count = dm_nrows(inhibit_matrix);
class_enabled = (vset_t*)RTmalloc(inhibit_class_count * sizeof(vset_t));
for(int i=0; i<inhibit_class_count; i++) {
class_enabled[i] = vset_create(domain, -1, NULL);
}
}
}
}
l_projs = (ci_list **) dm_rows_to_idx_table (GBgetStateLabelInfo(model));
for (int i = 0; i < sLbls; i++) {
/* Indeed, we skip unused state labels, but allocate memory for pointers
* (to vset_t's). Is this bad? Maybe a hashmap is worse. */
if (bitvector_is_set(&state_label_used, i)) {
if (HREme(HREglobal()) == 0) {
label_false[i] = vset_create(domain, l_projs[i]->count, l_projs[i]->data);
label_true[i] = vset_create(domain, l_projs[i]->count, l_projs[i]->data);
label_tmp[i] = vset_create(domain, l_projs[i]->count, l_projs[i]->data);
}
} else {
label_false[i] = NULL;
label_true[i] = NULL;
label_tmp[i] = NULL;
}
}
inv_set = (vset_t *) RTmalloc(sizeof(vset_t[num_inv]));
for (int i = 0; i < num_inv; i++) {
inv_set[i] = vset_create (domain, inv_proj[i]->count, inv_proj[i]->data);
inv_info_prepare (inv_expr[i], inv_parse_env[i], i);
}
}
