lts_file_t aut_file_create(const char* name,lts_type_t ltstype,int segments,lts_file_t settings){
if (lts_type_get_state_length(ltstype)) {
//Abort("cannot write state to AUT file");
Print(infoShort,"Ignoring state vector");
}
if (lts_type_get_state_label_count(ltstype)) {
Abort("cannot write state labels to AUT file");
}
if (lts_type_get_edge_label_count(ltstype)!=1) {
Abort("AUT files contain precisely one edge label");
}
if (segments!=1) Abort("AUT files contain precisely 1 segment");
lts_file_t file=lts_file_bare(name,ltstype,1,settings,sizeof(struct lts_file_s));
file->f=fopen(name,"w");
if(file->f==NULL){
AbortCall("while opening %s",name);
}
file->root--; // set to -1 denoting undefined.
file->states++; // set to 1, denoting one state.
file->type_no=lts_type_get_edge_label_typeno(ltstype,0);
lts_file_set_write_init(file,aut_write_init);
lts_file_set_write_state(file,write_state);
lts_file_set_write_edge(file,aut_write_edge);
lts_file_set_close(file,aut_write_close);
fprintf(file->f,"des(?,?,?) \n");
lts_file_complete(file);
return file;
}
void lts_type_serialize(lts_type_t t,stream_t ds){
DSwriteS(ds,"lts signature 1.1");
uint32_t N=lts_type_get_state_length(t);
Warning(debug,"state length is %d",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_state_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_state_typeno(t,i));
}
N=lts_type_get_state_label_count(t);
Warning(debug,"%d state labels",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_state_label_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_state_label_typeno(t,i));
}
N=lts_type_get_edge_label_count(t);
Warning(debug,"%d edge labels",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_edge_label_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_edge_label_typeno(t,i));
Warning(debug,"edge label %d is %s : %s",i,x,lts_type_get_edge_label_type(t,i));
}
N=lts_type_get_type_count(t);
Warning(debug,"%d types",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
DSwriteS(ds,lts_type_get_type(t,i));
DSwriteS(ds,(char*)data_format_string(t,i));
}
}
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());
}
static void default_push(lts_file_t src,lts_file_t dst){
if (SYSTEM(src)->ctx != SYSTEM(dst)->ctx) Abort("cannot copy between different contexts");
int me=HREme(SYSTEM(src)->ctx);
lts_type_t ltstype=lts_file_get_type(src);
int N1=lts_type_get_state_length(ltstype);
int N2=lts_type_get_state_label_count(ltstype);
int K=lts_type_get_edge_label_count(ltstype);
int do_state;
if (N1){
Print(infoLong,"vector length is %d",N1);
do_state=1;
} else {
do_state=N2?1:0;
N1=1;
}
int src_seg;
uint32_t src_state[N1];
int dst_seg;
uint32_t dst_state[N1];
uint32_t edge_labels[K];
if (me==0) {
Print(infoLong,"copying initial states");
int count=0;
while(lts_read_init(src,&src_seg,src_state)){
count++;
lts_write_init(dst,src_seg,src_state);
}
Print(infoLong,"%d initial state(s)",count);
}
for(int i=0;i<lts_file_owned_count(src);i++){
src_seg=lts_file_owned(src,i);
dst_seg=lts_file_owned(src,i);
if (do_state) {
Print(infoLong,"copying states of segment %d",src_seg);
uint32_t state_labels[N2];
while(lts_read_state(src,&src_seg,src_state,state_labels)){
lts_write_state(dst,src_seg,src_state,state_labels);
}
}
Print(infoLong,"copying edges of segment %d",src_seg);
while(lts_read_edge(src,&src_seg,src_state,&dst_seg,dst_state,edge_labels)){
lts_write_edge(dst,src_seg,src_state,dst_seg,dst_state,edge_labels);
}
}
Print(infoLong,"done");
}
lts_file_t lts_writer(lts_t lts,int segments,lts_file_t settings){
lts_file_t file=lts_file_bare("<heap>",lts->ltstype,segments,settings,sizeof(struct lts_file_s));
file->lts=lts;
file->segments=segments;
file->state_perseg=(uint32_t*)RTmallocZero(segments*sizeof(uint32_t));
file->edge_labels=lts_type_get_edge_label_count(lts->ltstype);
lts_file_set_write_init(file,write_init);
lts_file_set_write_state(file,write_state);
lts_file_set_write_edge(file,write_edge);
lts_file_set_close(file,write_close);
lts_file_complete(file);
lts_set_type(file->lts,LTS_LIST);
int T=lts_type_get_type_count(lts->ltstype);
for(int i=0;i<T;i++){
lts_file_set_table(file,i,lts->values[i]);
}
return file;
}
void lts_write(char *name,lts_t lts,string_set_t filter,int segments){
int format=lts_guess_format(name);
lts_type_t ltstype=lts->ltstype;
switch(format){
case LTS_IMCA:
lts_write_imca(name,lts);
break;
case LTS_TRA:
lts_write_tra(name,lts);
break;
case LTS_PG:
lts_write_pg(name,lts);
break;
case LTS_DIR:
if (lts_type_get_state_length(ltstype)==0
&& lts_type_get_state_label_count(ltstype)==0
&& lts_type_get_edge_label_count(ltstype)==1
){
archive_t archive=arch_dir_create(name,65536,DELETE_ALL);
lts_write_dir(archive,NULL,lts,segments);
arch_close(&archive);
break;
} else // fall through
default: {
lts_file_t src=lts_reader(lts,segments,NULL);
lts_file_t dst;
if (filter==NULL){
dst=lts_file_create(name,lts->ltstype,segments,src);
} else {
dst=lts_file_create_filter(name,lts->ltstype,filter,segments,src);
}
int T=lts_type_get_type_count(lts->ltstype);
for(int i=0;i<T;i++){
if (lts->values[i]) lts_file_set_table(dst,i,lts->values[i]);
}
lts_file_copy(src,dst);
lts_file_close(src);
lts_file_close(dst);
break;
}
}
}
lts_file_t lts_reader(lts_t lts,int segments,lts_file_t settings){
lts_file_t file=lts_file_bare("<heap>",lts->ltstype,segments,settings,sizeof(struct lts_file_s));
file->lts=lts;
file->segments=segments;
file->edge_labels=lts_type_get_edge_label_count(lts->ltstype);
lts_file_set_read_init(file,read_init);
lts_file_set_read_state(file,read_state);
lts_file_set_read_edge(file,read_edge);
lts_file_set_close(file,read_close);
lts_file_complete(file);
int T=lts_type_get_type_count(lts->ltstype);
for(int i=0;i<T;i++){
lts_file_set_table(file,i,lts->values[i]);
}
lts_set_type(file->lts,LTS_LIST);
file->init_count=0;
file->state_count=0;
file->edge_count=0;
return file;
}
int main(int argc, char *argv[]){
char* files[2];
HREinitBegin(argv[0]);
HREaddOptions(options,"Tool for transforming labeled transition systems\n\nOptions");
lts_lib_setup();
HREinitStart(&argc,&argv,1,2,files,"<input> [<output>]");
int me=HREme(HREglobal());
int peers=HREpeers(HREglobal());
if (peers>1) Abort("parallelizing this tool is future work");(void)me;
string_set_t label_set=NULL;
if (label_filter!=NULL){
label_set=SSMcreateSWPset(label_filter);
}
switch(task){
case Undefined:
Abort("task unspecified");
case LTScopy:
if (files[1]==NULL) Abort("second argument required for copy.");
Print(infoShort,"streaming copy from %s to %s",files[0],files[1]);
lts_file_t in=lts_file_open(files[0]);
lts_type_t ltstype=lts_file_get_type(in);
rd_seg=lts_file_get_segments(in);
if (wr_seg==0) {
wr_seg=rd_seg;
} else {
Abort("on-the-fly changing the number of segments is future work");
}
lts_file_t out;
if (label_set==NULL){
out=lts_file_create(files[1],ltstype,wr_seg,in);
} else {
out=lts_file_create_filter(files[1],ltstype,label_set,wr_seg,in);
}
int N=lts_type_get_type_count(ltstype);
for(int i=0;i<N;i++){
char*name=lts_type_get_type(ltstype,i);
switch(lts_type_get_format(ltstype,i)){
case LTStypeDirect:
case LTStypeRange:
Debug("integer type %s does not use tables",name);
break;
case LTStypeChunk:
case LTStypeEnum:
Debug("creating table for type %s",name);
value_table_t tmp=chunk_table_create(NULL,name);
Debug("set in %s",name);
lts_file_set_table(in,i,tmp);
Debug("set out %s",name);
lts_file_set_table(out,i,tmp);
break;
}
}
lts_file_copy(in,out);
lts_file_close(out);
lts_file_close(in);
break;
case LTSrdwr:
if (files[1]==NULL) Abort("second argument required for rdwr.");
Print(infoShort,"loading from %s",files[0]);
lts_t lts=lts_create();
lts_read(files[0],lts);
if (encode) {
Print(infoShort,"single edge label encoding");
lts=lts_encode_edge(lts);
}
if (bfs_reorder) {
Print(infoShort,"reindexing LTS in BFS order");
lts_bfs_reorder(lts);
}
Print(infoShort,"storing in %s",files[1]);
if(wr_seg==0) wr_seg=1;
lts_write(files[1],lts,label_set,wr_seg);
break;
case LTSindex:{
if (peers>1) Abort("parallelizing this tool is future work");
if (files[1]==NULL) Abort("second argument required for index.");
Print(infoShort,"opening %s",files[0]);
lts_file_t in=lts_file_open(files[0]);
lts_type_t ltstype=lts_file_get_type(in);
int segments=lts_file_get_segments(in);
lts_file_t settings=lts_get_template(in);
if (lts_file_get_edge_owner(settings)!=SourceOwned) Abort("bad edge owner");
lts_file_set_dest_mode(settings,Index);
lts_file_set_init_mode(settings,Index);
Print(infoShort,"creating %s",files[1]);
lts_file_t out=lts_file_create(files[1],ltstype,segments,settings);
int N=lts_type_get_type_count(ltstype);
for(int i=0;i<N;i++){
char*name=lts_type_get_type(ltstype,i);
switch(lts_type_get_format(ltstype,i)){
case LTStypeDirect:
case LTStypeRange:
Debug("integer type %s does not use tables",name);
break;
case LTStypeChunk:
case LTStypeEnum:
Debug("creating table for type %s",name);
value_table_t tmp=chunk_table_create(NULL,name);
Debug("set in %s",name);
lts_file_set_table(in,i,tmp);
Debug("set out %s",name);
lts_file_set_table(out,i,tmp);
break;
}
}
treedbs_t db[segments];
int SV=lts_type_get_state_length(ltstype);
int SL=lts_type_get_state_label_count(ltstype);
int K=lts_type_get_edge_label_count(ltstype);
for(int i=0;i<segments;i++){
Print(info,"loading and copying states of segment %d",i);
uint32_t state[SV];
uint32_t label[SL];
db[i]=TreeDBScreate(SV);
int idx=0;
while(lts_read_state(in,&i,state,label)){
int tmp=TreeFold(db[i],(int*)state);
if (idx!=tmp){
Abort("unexpected index %u != %u",tmp,idx);
}
idx++;
lts_write_state(out,i,(int*)state,label);
}
}
Print(info,"converting initial states");
{
uint32_t seg;
uint32_t state[SV];
while(lts_read_init(in,(int*)&seg,state)){
int idx=TreeFold(db[seg],(int*)state);
lts_write_init(out,seg,&idx);
}
}
for(int i=0;i<segments;i++){
Print(info,"converting edges of segment %d",i);
uint32_t src_state[1];
uint32_t dst_seg;
uint32_t dst_state[SV];
uint32_t label[K];
while(lts_read_edge(in,&i,src_state,(int*)&dst_seg,dst_state,label)){
int idx=TreeFold(db[dst_seg],(int*)dst_state);
lts_write_edge(out,i,src_state,dst_seg,&idx,label);
}
}
lts_file_close(out);
lts_file_close(in);
}
}
Print(infoShort,"done");
HREexit(LTSMIN_EXIT_SUCCESS);
}
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_INIT_GRAPH(void) {
char *opencaesar_args, *opencaesar_prog,*ltsmin_options;
int argc;
char **argv;
opencaesar_prog = getenv ("OPEN_CAESAR_PROG");
if (opencaesar_prog == NULL)
CAESAR_ERROR ("undefined environment variable $OPEN_CAESAR_PROG");
opencaesar_args = getenv ("OPEN_CAESAR_FILE");
if (opencaesar_args == NULL)
CAESAR_ERROR ("undefined environment variable $OPEN_CAESAR_FILE");
ltsmin_options = getenv ("LTSMIN_OPTIONS");
if (ltsmin_options == NULL)
CAESAR_ERROR ("undefined environment variable $LTSMIN_OPTIONS");
int len=strlen(opencaesar_prog)+strlen(ltsmin_options)+strlen(opencaesar_args);
char cmdline[len+6];
sprintf(cmdline,"%s %s %s",opencaesar_prog,ltsmin_options,opencaesar_args);
int res=poptParseArgvString(cmdline,&argc,(void*)(&argv));
if (res){
Abort("could not parse %s: %s",opencaesar_args,poptStrerror(res));
}
char *files[2];
HREinitBegin(argv[0]);
HREaddOptions(options,"Options");
HREinitStart(&argc,&argv,1,1,(char**)files,"<model>");
Warning(info,"loading model from %s",files[0]);
model=GBcreateBase();
GBsetChunkMethods(model,new_string_index,NULL,
(int2chunk_t)SIgetC,
(chunk2int_t)SIputC,
(chunkatint_t)SIputCAt,
(get_count_t)SIgetCount);
GBloadFile(model,files[0],&model);
ltstype=GBgetLTStype(model);
N = lts_type_get_state_length(ltstype);
K = dm_nrows(GBgetDMInfo(model));
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 (edge_encode){
edge_size=edge_labels+N+state_labels;
Warning(info,"encoding state information on edges");
} else {
edge_size=edge_labels;
Warning(info,"state information is hidden");
}
CAESAR_HINT_SIZE_STATE = N*sizeof(int);
CAESAR_HINT_HASH_SIZE_STATE = CAESAR_HINT_SIZE_STATE;
CAESAR_HINT_SIZE_LABEL = edge_size*sizeof(int);
CAESAR_HINT_HASH_SIZE_LABEL = CAESAR_HINT_SIZE_LABEL;
Warning(info,"CAESAR_HINT_SIZE_STATE=%lu CAESAR_HINT_SIZE_LABEL=%lu",
(unsigned long)CAESAR_HINT_SIZE_STATE,(unsigned long)CAESAR_HINT_SIZE_LABEL);
}
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;
}
return lts->seg_no;
}
hre_task_queue_t SLTSgetQueue(seg_lts_t lts){
return lts->task_queue;
}
seg_lts_t SLTScreate(lts_type_t signature,hre_task_queue_t task_queue,seg_lts_layout_t layout){
seg_lts_t lts=RT_NEW(struct seg_lts_s);
lts->sig=signature;
lts->task_queue=task_queue;
lts->seg_no=HREme(TQcontext(task_queue));
lts->seg_count=HREpeers(TQcontext(task_queue));
lts->state_length=lts_type_get_state_length(signature);
lts->state_labels=lts_type_get_state_label_count(signature);
lts->edge_labels=lts_type_get_edge_label_count(signature);
lts->layout=layout;
lts->vt_count=lts_type_get_type_count(signature);
lts->vt=RTmalloc(lts->vt_count*sizeof(value_table_t));
for(int i=0;i<lts->vt_count;i++) {
char *type_name=lts_type_get_type(signature,i);
lts->vt[i]=HREcreateTable(TQcontext(task_queue),type_name);
}
return lts;
}
int SLTSstateCount(seg_lts_t lts){
return lts->state_count;
}
int SLTSoutgoingCount(seg_lts_t lts){
void dve_write(const char*name,etf_model_t model){
lts_type_t ltstype=etf_type(model);
int N=lts_type_get_state_length(ltstype);
int K=lts_type_get_edge_label_count(ltstype);
int G=etf_trans_section_count(model);
// mapping section => pvar
int owner[G];
// default ownership if no state variable is written to
// this is so that self-transitions on state variables go in their own process
int defowner[G];
// mapping variable => type
int types[N];
pvar_slice(ltstype);
// count of sections per pvar
int g_count[pv_count+1];
for(int i=0;i<=pv_count;i++){
g_count[i]=0;
}
/* Analyze sections: find out which sections belong to which pvar */
// maximum value per variable
int max[N];
etf_get_initial(model,max);
if (pv_count) {
for(int i=0;i<G;i++) {
etf_rel_t trans=etf_trans_section(model,i);
int status[N];
int count=analyze_rel(trans,N,K,status,max);
owner[i]=-1;
defowner[i]=-1;
if(count==0) continue;
for(int j=0;j<N;j++){
for(int k=0;k<pv_count;k++){
if (pvar_idx[k]==j){
if(status[j]&0x2){
if (owner[i]==-1){
owner[i]=k;
} else {
Abort("group %d belongs to two processes",i);
}
} else if (status[j]&0x1) {
if (defowner[i]==-1) {
defowner[i]=k;
} else {
defowner[i]=pv_count;
}
}
}
}
}
if (owner[i]==-1) owner[i]=defowner[i];
if (owner[i]==-1) owner[i]=pv_count;
g_count[owner[i]]++;
Warning(info,"group %d belongs to proc %d",i,owner[i]);
}
} else {
for(int i=0;i<G;i++) {
owner[i]=0;
g_count[owner[i]]++;
}
}
/* Analyze variables: find out what type each variable is */
// pvar with at least one nonempty section: state variable
// always same owner: local variable
// otherwise: global
int var_owner[N];
for (int i=0;i<N;i++) {
types[i]=VAR_TYPE_UNKNOWN;
var_owner[i]=-1;
}
for (int i=0;i<pv_count;i++) {
types[pvar_idx[i]] = g_count[i]?VAR_TYPE_STATE:VAR_TYPE_GLOBAL;
}
if (pv_count) {
for (int i=0;i<G;i++) {
etf_rel_t trans=etf_trans_section(model,i);
int status[N];
int count=analyze_rel(trans,N,K,status,NULL);
if (!count) continue;
for (int j=0;j<N;j++) {
if (types[j]==VAR_TYPE_STATE) continue;
if (status[j]) {
if (var_owner[j]==-1) {
var_owner[j]=owner[i];
types[j]=VAR_TYPE_LOCAL;
} else {
if (var_owner[j]!=owner[i]) {
types[j]=VAR_TYPE_GLOBAL;
}
}
}
}
}
for (int i=0;i<N;i++) {
char *typename;
switch(types[i]) {
case VAR_TYPE_STATE: typename="state"; break;
case VAR_TYPE_LOCAL: typename="local"; break;
case VAR_TYPE_GLOBAL: typename="global"; break;
default: typename="unknown"; break;
}
Warning(info,"variable %s is %s",lts_variable_name(ltstype,i),typename);
}
} else {
for(int i=0;i<N;i++) {
void
ETFloadGreyboxModel(model_t model, const char *name)
{
gb_context_t ctx=(gb_context_t)RTmalloc(sizeof(struct grey_box_context));
GBsetContext(model,ctx);
etf_model_t etf=etf_parse_file(name);
lts_type_t ltstype=etf_type(etf);
int state_length=lts_type_get_state_length(ltstype);
ctx->edge_labels=lts_type_get_edge_label_count(ltstype);
if (ctx->edge_labels>1) {
ctx->label_idx=SIcreate();
} else {
ctx->label_idx=NULL;
}
GBsetLTStype(model,ltstype);
matrix_t* p_dm_info = (matrix_t*)RTmalloc(sizeof(matrix_t));
matrix_t* p_dm_read_info = (matrix_t*)RTmalloc(sizeof(matrix_t));
matrix_t* p_dm_write_info = (matrix_t*)RTmalloc(sizeof(matrix_t));
dm_create(p_dm_info, etf_trans_section_count(etf), state_length);
dm_create(p_dm_read_info, etf_trans_section_count(etf), state_length);
dm_create(p_dm_write_info, etf_trans_section_count(etf), state_length);
ctx->trans_key_idx=(string_index_t*)RTmalloc(dm_nrows(p_dm_info)*sizeof(string_index_t));
ctx->trans_table=(matrix_table_t*)RTmalloc(dm_nrows(p_dm_info)*sizeof(matrix_table_t));
for(int i=0; i < dm_nrows(p_dm_info); i++) {
Warning(infoLong,"parsing table %d",i);
etf_rel_t trans=etf_trans_section(etf,i);
int used[state_length];
int src[state_length];
int dst[state_length];
int lbl[ctx->edge_labels];
int proj[state_length];
ETFrelIterate(trans);
if (!ETFrelNext(trans,src,dst,lbl)){
Abort("unexpected empty transition section");
}
int len=0;
for(int j=0;j<state_length;j++){
if (src[j]) {
proj[len]=j;
Warning(debug,"pi[%d]=%d",len,proj[len]);
len++;
dm_set(p_dm_info, i, j);
used[j]=1;
} else {
used[j]=0;
}
}
Warning(infoLong,"length is %d",len);
ctx->trans_key_idx[i]=SIcreate();
ctx->trans_table[i]=MTcreate(3);
int src_short[len];
int dst_short[len];
uint32_t row[3];
do {
/*
* If an element is non-zero, we always consider it a read. If the
* value is changed for at least one transition in a group then
* we also consider it a write. Note that this could be slightly
* optimized by omitting those elements from read where the value
* varies over all possible inputs.
*/
for(int k=0;k<state_length;k++) {
if (src[k] != 0) {
dm_set(p_dm_read_info, i, k);
if (src[k] != dst[k]) dm_set(p_dm_write_info, i, k);
}
}
for(int k=0;k<state_length;k++) {
if(used[k]?(src[k]==0):(src[k]!=0)){
Abort("inconsistent section in src vector");
}
}
for(int k=0;k<len;k++) src_short[k]=src[proj[k]]-1;
for(int k=0;k<state_length;k++) {
if(used[k]?(dst[k]==0):(dst[k]!=0)){
Abort("inconsistent section in dst vector");
}
}
for(int k=0;k<len;k++) dst_short[k]=dst[proj[k]]-1;
row[0]=(uint32_t)SIputC(ctx->trans_key_idx[i],(char*)src_short,len<<2);
switch(ctx->edge_labels){
case 0:
row[2]=0;
break;
case 1:
row[2]=(uint32_t)lbl[0];
break;
default:
row[2]=(uint32_t)SIputC(ctx->label_idx,(char*)lbl,(ctx->edge_labels)<<2);
break;
}
row[1]=(int32_t)SIputC(ctx->trans_key_idx[i],(char*)dst_short,len<<2);
MTaddRow(ctx->trans_table[i],row);
} while(ETFrelNext(trans,src,dst,lbl));
Warning(infoLong,"table %d has %d states and %d transitions",
i,SIgetCount(ctx->trans_key_idx[i]),ETFrelCount(trans));
ETFrelDestroy(&trans);
MTclusterBuild(ctx->trans_table[i],0,SIgetCount(ctx->trans_key_idx[i]));
}
GBsetDMInfo(model, p_dm_info);
/*
* Set these again when ETF supports read, write and copy.
GBsetDMInfoRead(model, p_dm_read_info);
GBsetDMInfoMustWrite(model, p_dm_write_info);
GBsetSupportsCopy(model); // no may-write so we support copy.
*/
GBsetNextStateShort(model,etf_short);
matrix_t *p_sl_info = RTmalloc(sizeof *p_sl_info);
dm_create(p_sl_info, etf_map_section_count(etf), state_length);
ctx->label_key_idx=(string_index_t*)RTmalloc(dm_nrows(p_sl_info)*sizeof(string_index_t));
ctx->label_data=(int**)RTmalloc(dm_nrows(p_sl_info)*sizeof(int*));
for(int i=0;i<dm_nrows(p_sl_info);i++){
Warning(infoLong,"parsing map %d",i);
etf_map_t map=etf_get_map(etf,i);
int used[state_length];
int state[state_length];
int value;
ETFmapIterate(map);
if (!ETFmapNext(map,state,&value)){
Abort("Unexpected empty map");
}
int len=0;
for(int j=0;j<state_length;j++){
if (state[j]) {
used[len]=j;
len++;
dm_set(p_sl_info, i, j);
}
}
int*proj=(int*)RTmalloc(len*sizeof(int));
for(int j=0;j<len;j++) proj[j]=used[j];
for(int j=0;j<state_length;j++) used[j]=state[j];
string_index_t key_idx=SIcreate();
int *data=(int*)RTmalloc(ETFmapCount(map)*sizeof(int));
int key[len];
do {
for(int k=0;k<state_length;k++) {
if(used[k]?(state[k]==0):(state[k]!=0)){
Abort("inconsistent map section");
}
}
for(int k=0;k<len;k++) key[k]=state[proj[k]]-1;
data[SIputC(key_idx,(char*)key,len<<2)]=value;
} while(ETFmapNext(map,state,&value));
ctx->label_key_idx[i]=key_idx;
ctx->label_data[i]=data;
}
GBsetStateLabelInfo(model, p_sl_info);
GBsetStateLabelShort(model,etf_state_short);
GBsetTransitionInGroup(model,etf_transition_in_group);
int type_count=lts_type_get_type_count(ltstype);
for(int i=0;i<type_count;i++){
Warning(infoLong,"Setting values for type %d (%s)",i,lts_type_get_type(ltstype,i));
int count=etf_get_value_count(etf,i);
for(int j=0;j<count;j++){
GBchunkPutAt(model,i,etf_get_value(etf,i,j),j);
}
}
int state[state_length];
etf_get_initial(etf,state);
GBsetInitialState(model,state);
}
static void write_close(lts_file_t file){
//if (file->init_count!=1) Abort("missing initial state"); in some cases no initial states makes sense!
uint32_t pre_sum=0;
for(int i=0;i<file->segments;i++) pre_sum+=file->state_perseg[i];
uint32_t tmp;
for (int i=0;i<file->segments;i++){
tmp=lts_get_max_src_p1(file,i);
if (tmp>file->state_perseg[i]) file->state_perseg[i]=tmp;
tmp=lts_get_max_dst_p1(file,i);
if (tmp>file->state_perseg[i]) file->state_perseg[i]=tmp;
}
file->state_count=0;
for(int i=0;i<file->segments;i++) file->state_count+=file->state_perseg[i];
if (pre_sum && pre_sum!=file->state_count) {
Abort("edges use unwritten states");
}
uint32_t offset[file->segments];
offset[0]=0;
for(int i=1;i<file->segments;i++) offset[i]=offset[i-1]+file->state_perseg[i-1];
uint32_t seg,ofs;
for(uint32_t i=0;i<file->lts->root_count;i++){
seg=file->lts->root_list[i]%file->segments;
ofs=file->lts->root_list[i]/file->segments;
file->lts->root_list[i]=offset[seg]+ofs;
}
for(uint32_t i=0;i<file->edge_count;i++){
seg=file->lts->src[i]%file->segments;
ofs=file->lts->src[i]/file->segments;
file->lts->src[i]=offset[seg]+ofs;
seg=file->lts->dest[i]%file->segments;
ofs=file->lts->dest[i]/file->segments;
file->lts->dest[i]=offset[seg]+ofs;
}
if (file->lts->properties){
uint32_t* temp=file->lts->properties;
file->lts->properties=(uint32_t*)RTmalloc(file->state_count*sizeof(uint32_t));
for(int i=0;i<file->segments;i++){
for(uint32_t j=0;j<file->state_perseg[i];j++){
file->lts->properties[offset[i]+j]=temp[j*file->segments+i];
}
}
RTfree(temp);
}
lts_set_size(file->lts,file->init_count,file->state_count,file->edge_count);
file->lts->tau=-1;
if (lts_type_get_edge_label_count(file->lts->ltstype)==1 &&
strncmp(lts_type_get_edge_label_name(file->lts->ltstype,0),LTSMIN_EDGE_TYPE_ACTION_PREFIX,6)==0)
{
Print(infoShort,"action labeled, detecting silent step");
int tableno=lts_type_get_edge_label_typeno(file->lts->ltstype,0);
value_table_t vt=file->lts->values[tableno];
int N=VTgetCount(vt);
for(int i=0;i<N;i++){
chunk c=VTgetChunk(vt,i);
if ( (c.len==strlen(LTSMIN_EDGE_VALUE_TAU) && strcmp(c.data,LTSMIN_EDGE_VALUE_TAU)==0)
|| (c.len==1 && strcmp(c.data,"i")==0)
)
{
Print(infoShort,"invisible label is %s",c.data);
if (file->lts->tau>=0) Abort("two silent labels");
file->lts->tau=i;
}
}
if (file->lts->tau<0) {
Print(infoShort,"no silent label");
}
}
}
