void pins_model_init(model_t m) {
// create the LTS type LTSmin will generate
lts_type_t ltstype=lts_type_create();
// set the length of the state
lts_type_set_state_length(ltstype, state_length());
// add an "int" type for a state slot
int int_type = lts_type_add_type(ltstype, "int", NULL);
lts_type_set_format (ltstype, int_type, LTStypeDirect);
// add an "action" type for edge labels
int action_type = lts_type_add_type(ltstype, "action", NULL);
lts_type_set_format (ltstype, action_type, LTStypeEnum);
// add a "bool" type for state labels
int bool_type = lts_type_add_type (ltstype, LTSMIN_TYPE_BOOL, NULL);
lts_type_set_format(ltstype, bool_type, LTStypeEnum);
// set state name & type
for (int i=0; i < state_length(); ++i) {
char name[3]; sprintf(name, "%d", i);
lts_type_set_state_name(ltstype,i,name);
lts_type_set_state_typeno(ltstype,i,int_type);
}
// edge label types
lts_type_set_edge_label_count (ltstype, 1);
lts_type_set_edge_label_name(ltstype, 0, "action");
lts_type_set_edge_label_type(ltstype, 0, "action");
lts_type_set_edge_label_typeno(ltstype, 0, action_type);
// state label types
lts_type_set_state_label_count (ltstype, 1);
lts_type_set_state_label_name (ltstype, 0, "goal");
lts_type_set_state_label_typeno (ltstype, 0, bool_type);
// done with ltstype
lts_type_validate(ltstype);
// make sure to set the lts-type before anything else in the GB
GBsetLTStype(m, ltstype);
// setting all values for all non direct types
GBchunkPut(m, action_type, chunk_str("switch_a"));
GBchunkPut(m, action_type, chunk_str("switch_b"));
GBchunkPut(m, action_type, chunk_str("switch_c"));
GBchunkPut(m, action_type, chunk_str("switch_d"));
GBchunkPut(m, action_type, chunk_str("switch_ab"));
GBchunkPut(m, action_type, chunk_str("switch_ac"));
GBchunkPut(m, action_type, chunk_str("switch_ad"));
GBchunkPut(m, action_type, chunk_str("switch_bc"));
GBchunkPut(m, action_type, chunk_str("switch_bd"));
GBchunkPut(m, action_type, chunk_str("switch_cd"));
GBchunkPut(m, bool_type, chunk_str(LTSMIN_VALUE_BOOL_FALSE));
GBchunkPut(m, bool_type, chunk_str(LTSMIN_VALUE_BOOL_TRUE));
// set state variable values for initial state
GBsetInitialState(m, initial_state());
// set function pointer for the next-state function
GBsetNextStateLong(m, (next_method_grey_t) next_state);
// set function pointer for the label evaluation function
GBsetStateLabelLong(m, (get_label_method_t) state_label);
// create combined matrix
matrix_t *cm = malloc(sizeof(matrix_t));
dm_create(cm, group_count(), state_length());
// set the read dependency matrix
matrix_t *rm = malloc(sizeof(matrix_t));
dm_create(rm, group_count(), state_length());
for (int i = 0; i < group_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (read_matrix(i)[j]) {
dm_set(cm, i, j);
dm_set(rm, i, j);
}
}
}
GBsetDMInfoRead(m, rm);
// set the write dependency matrix
matrix_t *wm = malloc(sizeof(matrix_t));
dm_create(wm, group_count(), state_length());
for (int i = 0; i < group_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (write_matrix(i)[j]) {
dm_set(cm, i, j);
dm_set(wm, i, j);
}
}
}
GBsetDMInfoMustWrite(m, wm);
// set the combined matrix
GBsetDMInfo(m, cm);
// set the label dependency matrix
matrix_t *lm = malloc(sizeof(matrix_t));
dm_create(lm, label_count(), state_length());
for (int i = 0; i < label_count(); i++) {
for (int j = 0; j < state_length(); j++) {
if (label_matrix(i)[j]) dm_set(lm, i, j);
}
}
GBsetStateLabelInfo(m, lm);
}
void pins_model_init(model_t model)
{
lts_type_t ltstype;
matrix_t *dm_info = malloc(sizeof(matrix_t));
matrix_t *dm_read_info = malloc(sizeof(matrix_t));
matrix_t *dm_must_write_info = malloc(sizeof(matrix_t));
// get ltstypes
ltstype=lts_type_create();
const int state_length = pnml_vars;
// adding types
int ntypes = 2;
int int_type = lts_type_add_type(ltstype, "int", NULL);
int act_type =lts_type_add_type(ltstype, "action", NULL);
lts_type_set_format (ltstype, int_type, LTStypeDirect);
lts_type_set_format (ltstype, act_type, LTStypeEnum);
lts_type_set_state_length(ltstype, state_length);
// set state name & type
for (int i=0; i < state_length; ++i) {
lts_type_set_state_name(ltstype,i,pnml_var_names[i]);
lts_type_set_state_typeno(ltstype,i,int_type);
}
// edge label types
lts_type_set_edge_label_count (ltstype, 1);
lts_type_set_edge_label_name(ltstype, 0, "action");
lts_type_set_edge_label_type(ltstype, 0, "action");
lts_type_set_edge_label_typeno(ltstype, 0, act_type);
int bool_is_new, bool_type = lts_type_add_type(ltstype, LTSMIN_TYPE_BOOL, NULL);
GBsetLTStype(model, ltstype); // must set ltstype before setting initial state
// creates tables for types!
if (bool_is_new) {
GBchunkPutAt(model, bool_type, chunk_str(LTSMIN_VALUE_BOOL_FALSE), 0);
GBchunkPutAt(model, bool_type, chunk_str(LTSMIN_VALUE_BOOL_TRUE ), 1);
}
// setting values for types
for (int i = 0; i < pnml_groups; i++) {
GBchunkPutAt(model, act_type, chunk_str((char*) pnml_group_names[i]), i);
}
// get initial state
GBsetInitialState(model,pnml_initial_state);
for (int i = 0; i < pnml_vars; i++) {
if (max_token_count < pnml_initial_state[i]) {
max_token_count = pnml_initial_state[i];
}
}
// get next state
GBsetNextStateLong(model, (next_method_grey_t) pnml_get_successor);
lts_type_validate(ltstype); // done with ltstype
// initialize the state read/write dependency matrices
dm_create(dm_read_info, pnml_groups, state_length);
dm_create(dm_must_write_info, pnml_groups, state_length);
for (int i = 0; i < pnml_groups; i++) {
for (int j = 0; j < pnml_sources[i][0]; j++) {
dm_set(dm_read_info, i, pnml_sources[i][j*2+1]);
dm_set(dm_must_write_info, i, pnml_sources[i][j*2+1]);
}
for (int j = 0; j < pnml_targets[i][0]; j++) {
if (!pnml_safe_places[pnml_targets[i][j*2+1]]) {
/* If the place is safe we don't need to mark it read-dependent. */
dm_set(dm_read_info, i, pnml_targets[i][j*2+1]);
}
dm_set(dm_must_write_info, i, pnml_targets[i][j*2+1]);
}
}
dm_copy(dm_read_info, dm_info);
dm_apply_or(dm_info, dm_must_write_info);
GBsetDMInfo(model, dm_info);
GBsetDMInfoRead(model, dm_read_info);
GBsetDMInfoMustWrite(model, dm_must_write_info);
GBsetSupportsCopy(model);
GBsetExit(model, pnml_exit);
matrix_t *dna_info = malloc(sizeof(matrix_t));
dm_create(dna_info, pnml_groups, pnml_groups);
for (int i = 0; i < pnml_groups; i++) {
for(int j = 0; j < pnml_groups; j++) {
const int guards_i = pnml_sources[i][0];
const int guards_j = pnml_sources[j][0];
for (int g = 0; g < guards_i; g++) {
const int guard_i = pnml_sources[i][g * 2 + 1];
for (int h = 0; h < guards_j; h++) {
const int guard_j = pnml_sources[j][h * 2 + 1];
if (guard_i == guard_j) {
dm_set(dna_info, i, j);
goto next_dna;
}
}
}
next_dna:;
}
}
GBsetDoNotAccordInfo(model, dna_info);
matrix_t *gnes_info = malloc(sizeof(matrix_t));
dm_create(gnes_info, pnml_vars, pnml_groups);
for(int i = 0; i < pnml_groups; i++) {
const int targets = pnml_targets[i][0];
for (int t = 0; t < targets; t++) {
const int target = pnml_targets[i][t * 2 + 1];
dm_set(gnes_info, target, i);
}
}
GBsetGuardNESInfo(model, gnes_info);
matrix_t *gnds_info = malloc(sizeof(matrix_t));
dm_create(gnds_info, pnml_vars, pnml_groups);
for(int i = 0; i < pnml_groups; i++) {
const int sources = pnml_sources[i][0];
for (int s = 0; s < sources; s++) {
const int source = pnml_sources[i][s * 2 + 1];
dm_set(gnds_info, source, i);
}
}
GBsetGuardNDSInfo(model, gnds_info);
matrix_t *ndb_info = malloc(sizeof(matrix_t));
dm_create(ndb_info, pnml_groups, pnml_groups);
for (int i = 0; i < pnml_groups; i++) {
const int sources = pnml_sources[i][0];
for (int j = 0; j < pnml_groups; j++) {
const int targets = pnml_targets[j][0];
for (int s = 0; s < sources; s++) {
const int source = pnml_sources[i][s * 2 + 1];
for (int t = 0; t < targets; t++) {
const int target = pnml_targets[j][t * 2 + 1];
if (source == target) {
dm_set(ndb_info, i, j);
goto next_ndb;
}
}
}
next_ndb:;
}
}
GBsetMatrix(model, LTSMIN_NOT_LEFT_ACCORDS, ndb_info, PINS_STRICT, PINS_INDEX_OTHER, PINS_INDEX_OTHER);
}
lts_type_t lts_type_deserialize(stream_t ds){
lts_type_t t=lts_type_create();
char version[1024];
DSreadS(ds,version,1024);
int has_format_info;
if (strcmp(version,"lts signature 1.1")==0){
has_format_info=1;
} else if (strcmp(version,"lts signature 1.0")==0){
has_format_info=0;
} else {
Abort("cannot deserialize %s",version);
}
uint32_t N=DSreadU32(ds);
Warning(debug,"state length is %d",N);
lts_type_set_state_length(t,N);
for(uint32_t i=0;i<N;i++){
char*x=DSreadSA(ds);
if (strlen(x)) lts_type_set_state_name(t,i,x);
RTfree(x);
lts_type_set_state_typeno(t,i,DSreadU32(ds));
}
N=DSreadU32(ds);
Warning(debug,"%d state labels",N);
lts_type_set_state_label_count(t,N);
for(uint32_t i=0;i<N;i++){
char*x=DSreadSA(ds);
if (strlen(x)) lts_type_set_state_label_name(t,i,x);
RTfree(x);
lts_type_set_state_label_typeno(t,i,DSreadU32(ds));
}
N=DSreadU32(ds);
Warning(debug,"%d edge labels",N);
lts_type_set_edge_label_count(t,N);
for(uint32_t i=0;i<N;i++){
char*x=DSreadSA(ds);
if (strlen(x)) lts_type_set_edge_label_name(t,i,x);
RTfree(x);
lts_type_set_edge_label_typeno(t,i,DSreadU32(ds));
}
N=DSreadU32(ds);
Warning(debug,"%d types",N);
for(uint32_t i=0;i<N;i++){
char*x=DSreadSA(ds);
int tmp=lts_type_add_type(t,x,NULL);
if (tmp!=(int)i) Abort("bad type add");
RTfree(x);
if (has_format_info) {
x=DSreadSA(ds);
if (strcmp(x,"direct")==0){
lts_type_set_format(t,i,LTStypeDirect);
} else if (strcmp(x,"chunk")==0){
lts_type_set_format(t,i,LTStypeChunk);
} else if (strcmp(x,"enum")==0){
lts_type_set_format(t,i,LTStypeEnum);
} else {
int n=strlen(x);
if (x[0]=='[' && x[n-1]==']') {
int k=0;
while(k<n && x[k]!=',') k++;
if (k<n) {
lts_type_set_format(t,i,LTStypeRange);
lts_type_set_range(t,i,atoi(x+1),atoi(x+k+1));
}
}
Abort("unsupported data format %s",x);
}
RTfree(x);
} else {
lts_type_set_format(t,i,LTStypeChunk);
}
}
return t;
}
