예제 #1
0
static int weak_essential(int*sig,int*repr,int src,int label,int dest,int tau){
	int set,set2;
	for(set=sig[repr[src]];set!=EMPTY_SET;set=SetGetParent(set)){
		if (SetGetLabel(set)==label){
			for(set2=sig[repr[SetGetDest(set)]];set2!=EMPTY_SET;set2=SetGetParent(set2)){
				if (SetGetLabel(set2)==tau && SetGetDest(set2)==dest) return 0;
			}
		}
	}
	if (label==tau) return 1;
	for(set=sig[repr[src]];set!=EMPTY_SET;set=SetGetParent(set)){
		if (SetGetLabel(set)==tau){
			for(set2=sig[repr[SetGetDest(set)]];set2!=EMPTY_SET;set2=SetGetParent(set2)){
				if (SetGetLabel(set2)==label && SetGetDest(set2)==dest) return 0;
			}
		}
	}
	return 1;
}
예제 #2
0
static int mkdet_next(lts_t orig,int l,int S){
	int T,s,i;
	if (S==EMPTY_SET) return EMPTY_SET;
	T=mkdet_next(orig,l,SetGetParent(S));
	s=SetGetDest(S);
	for(i=orig->begin[s];i<orig->begin[s+1];i++){
		if(orig->label[i]==l){
			T=SetInsert(T,0,orig->dest[i]);
		}
	}
	return T;
}
예제 #3
0
void setbased_weak_reduce(lts_t lts){
	int tau,count,i,iter,setcount,set,*repr,t_count,num_states;
	int *map,*newmap;

	tau=lts->tau;
	lts_tau_cycle_elim(lts);
    Print(info,"size after tau cycle elimination is %d states and %d transitions",lts->states,lts->transitions);
	num_states=lts->states;
	map=(int*)malloc(sizeof(int)*lts->states);
	newmap=(int*)malloc(sizeof(int)*lts->states);
	lts_sort(lts);
	lts_set_type(lts,LTS_BLOCK_INV);
	for(i=0;i<num_states;i++){
		map[i]=0;
		newmap[i]=EMPTY_SET;
	}
	count=1;
	iter=0;
	for(;;){
		SetClear(-1);
		iter++;
		for(i=0;i<num_states;i++){
			dfs_weak_tau(lts,tau,map,newmap,i,map[i]);
		}
		SetSetTag(newmap[lts->root_list[0]],0);
		setcount=1;
		for(i=0;i<num_states;i++){
			set=newmap[i];
			if (SetGetTag(set)<0) {
				//fprintf(stderr,"new set:");
				//PrintSet(stderr,set);
				//fprintf(stderr,"\n");
				SetSetTag(set,setcount);
				setcount++;
			}
		}
		Print(info,"count is %d",setcount);
		//for(i=0;i<num_states;i++){
		//	fprintf(stderr,"%d: old %d new %d sig ",i,map[i],SetGetTag(newmap[i]));
		//	SetPrintIndex(stderr,newmap[i],lts->label_string);
		//	fprintf(stderr,"\n");
		//}
		if(count==setcount) break;
		count=setcount;
		for(i=0;i<num_states;i++){
			map[i]=SetGetTag(newmap[i]);
			newmap[i]=EMPTY_SET;
		}
	}
	repr=(int*)malloc(sizeof(int)*count);
	for(i=0;i<count;i++) {
		repr[i]=-1;
	}
	t_count=0;
	for(i=0;i<(int)lts->states;i++){
		if(repr[map[i]]==-1){
			repr[map[i]]=i;
			t_count+=SetGetSize(newmap[i]);
		}
	}
	lts_set_type(lts,LTS_BLOCK);
	lts_set_size(lts,lts->root_count,count,t_count);
	uint32_t r_count=0;
 	for(i=0;i<(int)lts->root_count;i++){
	  uint32_t tmp=map[lts->root_list[i]];
	  uint32_t j=0;
	  for(;j<r_count;j++){
	    if (tmp==lts->root_list[j]){
	      break;
	    }
	  }
	  if (j==r_count){
    	  lts->root_list[r_count]=tmp;
	      r_count++;
      }
	}
	lts->begin[0]=0;
	for(i=0;i<(int)lts->states;i++){
		count=lts->begin[i];
		set=newmap[repr[i]];
		while(set!=EMPTY_SET){
			if(weak_essential(newmap,repr,i,SetGetLabel(set),SetGetDest(set),tau)){
				lts->label[count]=SetGetLabel(set);
				lts->dest[count]=SetGetDest(set);
				count++;
			}
			set=SetGetParent(set);
		}
		lts->begin[i+1]=count;
	}
	lts_set_size(lts,r_count,lts->states,count);
	SetFree();
	free(newmap);
	free(map);
	free(repr);
    Print(info,"set2 reduction took %d iterations",iter);
}
예제 #4
0
void set_reduce_tau_star_a(lts_t lts){
	int tau,*map,count,*newmap,i,*tmp,iter,s,l,d,setcount,j,set,tau_count,a_count;
	int reachable,r_count,t_count,*repr;
	lts_t inv;

	tau=lts->tau;
	if (tau_cycle_elim) {
		lts_tau_cycle_elim(lts);
		Warning(1,"size after tau cycle elimination is %d states and %d transitions",lts->states,lts->transitions);
	}
	if (tau_indir_elim) {
		lts_tau_indir_elim(lts);
		Warning(1,"size after trivial tau elimination is %d states and %d transitions",lts->states,lts->transitions);
	}
	map=(int*)malloc(sizeof(int)*lts->states);
	newmap=(int*)malloc(sizeof(int)*lts->states);
	lts_set_type(lts,LTS_LIST);
	inv=lts_create();
	lts_set_type(inv,LTS_LIST);
	lts_set_size(inv,lts->states,lts->transitions);
	inv->root=0;
	tau_count=0;
	a_count=0;
	for(i=0;i<lts->states;i++){
		map[i]=0;
	}
	map[lts->root]=1;
	for(i=0;i<lts->transitions;i++) {
		if (lts->label[i]!=tau) map[lts->dest[i]]++;
	}
	reachable=0;
	for(i=0;i<lts->states;i++){
		if(map[i]!=0){
			newmap[i]=reachable;
			reachable++;
		} else {
			newmap[i]=(lts->states)+reachable-i-1;
		}
	}
	Warning(1,"%d states are reachable",reachable); 
	for(i=0;i<lts->transitions;i++) {
		if (lts->label[i]==tau){
			inv->src[tau_count]=newmap[lts->dest[i]];
			inv->label[tau_count]=lts->label[i];
			inv->dest[tau_count]=newmap[lts->src[i]];
			tau_count++;
		} else {
			lts->src[a_count]=newmap[lts->src[i]];
			lts->label[a_count]=lts->label[i];
			lts->dest[a_count]=newmap[lts->dest[i]];
			a_count++;
		}
	}
	lts_set_size(inv,lts->states,tau_count);
	lts_set_size(lts,lts->states,a_count);
	lts_sort(lts);
	lts_set_type(lts,LTS_BLOCK);
	lts_set_type(inv,LTS_BLOCK);
	for(i=0;i<lts->states;i++){
		map[i]=0;
		newmap[i]=EMPTY_SET;
	}
	count=1;
	iter=0;
	for(;;){
		SetClear(-1);
		iter++;
		for(i=0;i<lts->states;i++){
			for(j=lts->begin[i];j<lts->begin[i+1];j++){
				dfs_insert_tau_star_a(inv,newmap,lts->label[j],map[lts->dest[j]],i);
			}
		}
		SetSetTag(newmap[lts->root],0);
		setcount=1;
		for(i=0;i<lts->states;i++){
			if (SetGetTag(newmap[i])<0) {
				//fprintf(stderr,"new set:");
				//PrintSet(stderr,set);
				//fprintf(stderr,"\n");
				SetSetTag(newmap[i],setcount);
				setcount++;
			}
			if (i==(reachable -1)) {
				Warning(2,"reachable count is %d",setcount);
				r_count=setcount;
			}
		}
		Warning(2,"count is %d",setcount);
		if(count==setcount) break;
		count=setcount;
		for(i=0;i<lts->states;i++){
			map[i]=SetGetTag(newmap[i]);
			newmap[i]=EMPTY_SET;
		}
	}
	repr=(int*)malloc(sizeof(int)*r_count);
	for(i=0;i<r_count;i++) {
		repr[i]=-1;
	}
	t_count=0;
	for(i=0;i<reachable;i++){
		if(repr[map[i]]==-1){
			repr[map[i]]=i;
			t_count+=SetGetSize(newmap[i]);
		}
	}
	lts_set_size(lts,r_count,t_count);
	lts->root=0;
	lts->begin[0]=0;
	for(i=0;i<r_count;i++){
		count=lts->begin[i];
		set=newmap[repr[i]];
		while(set!=EMPTY_SET){
			lts->label[count]=SetGetLabel(set);
			lts->dest[count]=SetGetDest(set);
			set=SetGetParent(set);
			count++;
		}
		lts->begin[i+1]=count;
	}
	SetFree();
	free(newmap);
	free(map);
	free(repr);
	Warning(1,"reduction took %d iterations",iter);
}
예제 #5
0
void set_reduce_branching2(lts_t lts){
	int tau,count,i,*tmp,iter,s,l,d,setcount,j,set,*repr,t_count,tag,num_states,last_trans;
	//int *map,*newmap;
	//lts_t inv;

	tau=lts->tau;
        lts_divergence_marking(lts);
	if (tau_cycle_elim) {
		lts_tau_cycle_elim(lts);
		Warning(1,"size after tau cycle elimination is %d states and %d transitions",lts->states,lts->transitions);
	}
	if (tau_indir_elim) {
		lts_tau_indir_elim(lts);
		Warning(1,"size after trivial tau elimination is %d states and %d transitions",lts->states,lts->transitions);
	}
	num_states=lts->states;
	map=(int*)malloc(sizeof(int)*lts->states);
	newmap=(int*)malloc(sizeof(int)*lts->states);
	lts_set_type(lts,LTS_LIST);
	inv=lts_create();
	lts_set_type(inv,LTS_LIST);
	lts_set_size(inv,lts->states,lts->transitions);
	inv->root=0;
	count=0;
	for(i=0;i<lts->transitions;i++) if (lts->label[i]==tau){
		inv->src[count]=lts->dest[i];
		inv->label[count]=lts->label[i];
		inv->dest[count]=lts->src[i];
		count++;
	}
	lts_set_size(inv,lts->states,count);
	lts_sort(lts);
	lts_set_type(lts,LTS_BLOCK);
	lts_set_type(inv,LTS_BLOCK);
	for(i=0;i<num_states;i++){
		map[i]=0;
		newmap[i]=EMPTY_SET;
	}
	count=1;
	iter=0;
	for(;;){
		SetClear(-1);
		iter++;
		for(i=0;i<num_states;i++){
			last_trans=lts->begin[i+1];
			for(j=lts->begin[i];j<last_trans;j++){
				label=lts->label[j];
				dest=map[lts->dest[j]];
				if (label!=tau || map[i]!=dest) {
					//dfs_insert(inv,map,newmap,lts->label[j],map[lts->dest[j]],i);
					dfs_insert(i);
				}
			}
		}
		SetSetTag(newmap[lts->root],0);
		setcount=1;
		for(i=0;i<num_states;i++){
			set=newmap[i];
			if (SetGetTag(set)<0) {
				//fprintf(stderr,"new set:");
				//PrintSet(stderr,set);
				//fprintf(stderr,"\n");
				SetSetTag(set,setcount);
				setcount++;
			}
		}
		Warning(2,"count is %d",setcount);
		if(count==setcount) break;
		count=setcount;
		for(i=0;i<num_states;i++){
			map[i]=SetGetTag(newmap[i]);
			newmap[i]=EMPTY_SET;
		}
	}
	repr=(int*)malloc(sizeof(int)*count);
	for(i=0;i<count;i++) {
		repr[i]=-1;
	}
	t_count=0;
	for(i=0;i<lts->states;i++){
		if(repr[map[i]]==-1){
			repr[map[i]]=i;
			t_count+=SetGetSize(newmap[i]);
		}
	}
	lts_set_size(lts,count,t_count);
	lts->root=0;
        lts->root2=map[lts->root2];
	lts->begin[0]=0;
	for(i=0;i<lts->states;i++){
		count=lts->begin[i];
		set=newmap[repr[i]];
		while(set!=EMPTY_SET){
			lts->label[count]=SetGetLabel(set);
			lts->dest[count]=SetGetDest(set);
			set=SetGetParent(set);
			count++;
		}
		lts->begin[i+1]=count;
	}
	SetFree();
	free(newmap);
	free(map);
	free(repr);
	Warning(1,"set2 reduction took %d iterations",iter);
}