process.java

PEPA模型性能分析工具

package semantic;

import java.util.Enumeration;
import java.util.Hashtable;

import trans.Debug;
import trans.NPair;
import trans.PQueue;
import trans.NQueue;

public class Process {
	private static Hashtable prodef;
	private static Hashtable resdef;
	private static Hashtable resmult;
	public static int pcount;
	public static PQueue queue;
	
	protected int Type=0;
	
	public static Process Var(String s)
	{
		return new Var(s);
	}
	public static Process Prefix(Activity a,Process p)
	{
		return new Prefix(a,p);
	}
	public static Process Sum(Process p1,Process p2)
	{
		return new Sum(p1,p2);
	}
	public static Process Coop(Process p1,ActionSet l,Process p2)
	{
		return new Coop(p1,l,p2);
	}
	public static Process Hide(Process p,ActionSet a)
	{
		return new Hide(p,a);
	}
	
	public static void initialize()
	{
		prodef=new Hashtable();
		resdef=new Hashtable();
		resmult=new Hashtable();
	}
	
	public static void addDef(String pro,Process P)
	{
		prodef.put(pro,P);
	}
	public static Process def(Process p)
	{
		if(p.Type==ProcessType.Var_tag)
		{
			Var P=(Var)p;
			String s=P.p;
			return def(s);
		}
		throw new Error();
	}
	public static Process def(String s)
	{
		return (Process)prodef.get((Object)s);
	}
	public static void addres(String s,Process p)
	{
		resdef.put(s,p);
	}
	public static void addmult(String s,Rate r,Process p)
	{
		resdef.put(s,p);
		resmult.put(s,r);
	}
	public String toString()
	{
		switch(this.Type)
		{
		case ProcessType.Coop_tag:
		{	Coop P=(Coop)this;
			Process p1=P.p1;
			Process p2=P.p2;
			ActionSet l=P.l;
			String s=l.toString();
			String S=s==null?"||":"<"+s+">";
			return p1.toString()+S+p2.toString();
		}
		case ProcessType.Hide_tag:
		{	Hide P=(Hide)this;
			ActionSet l=P.l;
			Process p1=P.p;
			return p1.toString()+"/"+l.toString();
		}
		case ProcessType.Sum_tag:
		{
			Sum P=(Sum)this;
			Process p1=P.p1;
			Process p2=P.p2;
			return p1.toString()+"+"+p2.toString();
		}
		case ProcessType.Prefix_tag:
		{
			Prefix P=(Prefix)this;
			Activity a=P.a;
			Process p=P.p;
			return a.toString()+"."+p.toString();
		}
		case ProcessType.Var_tag:
		{
			Var P=(Var)this;
			return P.p;
		}
		}
		return null;
	}
/*
	public static int compare(Process p1,Process p2)
	{
		 switch (p1.Type) {
         case ProcessType.Var_tag: 
         {
             String dpn = ((Var)p1).p; 
             if(p2.Type==ProcessType.Var_tag) 
             {
                 String epn =  ((Var)p2).p;
                 return epn.compareTo(dpn);
             }
                 return ProcessType.Var_tag;
         }
         case ProcessType.Prefix_tag: 
         {
             Prefix P1 = (Prefix)p1;
             Process fp = P1.p;
             Activity fa = P1.a; {
                 switch (p2.Type) 
                 {
                     case ProcessType.Prefix_tag: 
                     {
                         Prefix P2 = (Prefix)p2;
                         Process sp = P2.p;
                         Activity sa = P2.a;
                         int temp;
                         temp = fa.compare(sa);
                         if (temp != 0) return temp;
                         temp = fa.getRate().compare(sa.getRate());
                         if (temp != 0) return temp;
                         return compare(fp, sp);
                     }
                     case ProcessType.Var_tag: 
                     {
                         return - 1;
                     }
                 }
                 return 1;
             }
         }
         case ProcessType.Sum_tag: 
         {
             Process.Sum P1 = (Process.Sum)p1;
             Process dp2 = P1.p2;
             Process dp1 = P1.p1; 
             {
                 switch (p2.Type) 
                 {
                     case ProcessType.Sum_tag: 
                     {
                         Process.Sum P2= (Process.Sum)p2;
                         Process ep2 = P2.p2;
                         Process ep1 = P2.p1;
                         int temp;
                         temp = compare(dp1, ep1);
                         if (temp != 0) return temp;
                         return compare(dp2, ep2);
                     }
                 }
                 return 1;
             }
         }
		 }
		 return -1;
	}
		*/
	public boolean equals(Object o)
	{
		Process p=(Process)o;
		if(this.Type!=p.Type)
			return false;
		else
		{
			switch(this.Type)
			{
			case ProcessType.Coop_tag:
			{
				Coop comp1=(Coop)this;
				Coop comp2=(Coop)p;
				Process cp11=comp1.p1;
				Process cp12=comp1.p2;
				Process cp21=comp2.p1;
				Process cp22=comp2.p2;
				if(cp11.equals(cp21))
				{
					if(cp12.equals(cp22))
						return true;
					else return false;
				}
				return false;
			}
			case ProcessType.Hide_tag:
			{
				Hide comp1=(Hide)this;
				Hide comp2=(Hide)p;
				return comp1.p.equals(comp2.p);
			}
			case ProcessType.Prefix_tag:
			{
				Prefix comp1=(Prefix)this;
				Prefix comp2=(Prefix)p;
				Activity a1=comp1.a;
				Activity a2=comp2.a;
				if(a1.compare(a2)==0)
					return comp1.p.equals(comp2.p);
				return false;
			}
			case ProcessType.Sum_tag:
			{
				Sum comp1=(Sum)this;
				Sum comp2=(Sum)p;
				Process cp11=comp1.p1;
				Process cp12=comp1.p2;
				Process cp21=comp2.p1;
				Process cp22=comp2.p2;
				if(cp11.equals(cp21))
				{
					if(cp12.equals(cp22))
						return true;
					else return false;
				}
				return false;
			}
			case ProcessType.Var_tag:
			{
				Var comp1=(Var)this;
				Var comp2=(Var)p;
				return comp1.p.equals(comp2.p);
			}
			default:
				return false;
			}
		}
	}

	/*
	public static void PrintProcess()
	{
		Debug.println(6,"-------------------------Process Definition-------------------------");
		for(Enumeration e = prodef.keys();e.hasMoreElements();)
		{
			String def=(String)e.nextElement();
			Debug.println(6,def);
		}
	}
	*/
	public Rate getRate(Action a) throws RateException
	{
		switch(this.Type)
		{
		case ProcessType.Coop_tag:
		{
			Coop p=(Coop)this;
			Process p1=p.p1;
			Process p2=p.p2;
			ActionSet l=p.l;
			Rate r1=p1.getRate(a);
			Rate r2=p2.getRate(a);
			if(r1==null) return r2;
			if(r2==null) return r1;
			if(l.contain(a)) return r1.min(r2);
			else return r1.plus(r2);
		}
		case ProcessType.Hide_tag:
		{
			Hide p=(Hide)this;
			ActionSet l=p.l;
			Process p1=p.p;
			if(l.contain(a)) return p.getRate(a);
			else return(new Rate.Number(new Double(0.0)));
		}
		case ProcessType.Prefix_tag:
		{
			Prefix p=(Prefix)this;
			Activity act=p.a;
			if(a.equals(act)) return act.getRate();
			else return null;
		}
		case ProcessType.Sum_tag:
		{
			Sum p=(Sum)this;
			Process p1=p.p1;
			Process p2=p.p2;
			Rate r1=p1.getRate(a);
			Rate r2=p2.getRate(a);
			if(r1==null) return r2;
			if(r2==null) return r1;
			else return r1.plus(r2);
		}
		case ProcessType.Var_tag:
		{
			Var P=(Var)this;
			String s=P.p;
			return Process.def(s).getRate(a);
		}
		}
		throw new Error();
	}
	public NQueue derivatives() throws RateException
	{
		NQueue nqueue=new NQueue();
		switch(this.Type)
		{
		case ProcessType.Coop_tag:
		{
			Coop p=(Coop)this;
			Process p1=p.p1;
			Process p2=p.p2;
			ActionSet l=p.l;
			NQueue q1=p1.derivatives();
			NQueue q2=p2.derivatives();
			if(!l.isEmpty())
			{
				NQueue q3=new NQueue();
				NQueue q4=new NQueue();
				q3.copy(q1);
				q4.copy(q2);
				while(!q3.isEmpty())
				{
					NPair np1=(NPair)q3.pop();
					if(l.contain((Action)np1.fst))
					{
						while(!q4.isEmpty())
						{
							NPair np2=(NPair)q4.pop();
							if(np2.fst.equals(np1.fst))
							{
								Activity join;
								 join = ((Activity)np1.fst).coopwith((Activity)np2.fst, p1, p2);
								 nqueue.push((Object)new NPair(join,Coop(np1.snd, l, np2.snd)));
                             }
						}
						q4.copy(q2);
					}
				}
			}
			while(!q1.isEmpty())
			{
				NPair np=(NPair)q1.pop();
				if(!l.contain((Action)np.fst))
					nqueue.push((Object)new NPair(np.fst, Coop(np.snd, l, p2)));
			}
			while(!q2.isEmpty())
			{
				NPair np=(NPair)q2.pop();
				if(!l.contain((Action)np.fst))
					nqueue.push((Object)new NPair(np.fst, Coop(p1, l, np.snd)));
			}
			break;
		}
		case ProcessType.Hide_tag:
		{
			Hide P=(Hide)this;
			ActionSet l=P.l;
			Process p=P.p;
			NQueue q=p.derivatives();
			while(!q.isEmpty())
			{
				NPair np=(NPair)q.pop();
				Activity act=np.fst;
				Process pro=np.snd;
				if(!l.contain(act))
				{
					nqueue.push(new NPair(act, Hide(p,l)));
				}
				else
				{
					Activity na=new Activity("temp",act.getRate());
					nqueue.push(new NPair(na, Hide(p,l)));
				}
			}
			break;
		}
		case ProcessType.Prefix_tag:
		{
			Prefix P=(Prefix)this;
			Activity a=P.a;
			Process p=P.p;
			nqueue.push(new NPair(a,p));
			break;
		}
		case ProcessType.Sum_tag:
		{
			Sum P=(Sum)this;
			Process p1=P.p1;
			Process p2=P.p2;
			NQueue dq1=p1.derivatives();
			NQueue dq2=p2.derivatives();
			nqueue.copy(dq1);
			nqueue.concat(dq2);
			break;
		}
		case ProcessType.Var_tag:
		{
			Var P=(Var)this;
			String s=P.p;
			nqueue=(P.def(s)).derivatives();
			break;
		}
		}
		return nqueue;
	}
	
	public static class Var extends Process
	{
		public String p;
		public Var(String s)
		{
			p=s;
			this.Type=ProcessType.Var_tag;
		}
	}
	
	public static class Prefix extends Process
	{
		public Activity a;
		public Process p;
		public Prefix(Activity A,Process P)
		{
			a=A;
			p=P;
			this.Type=ProcessType.Prefix_tag;
		}
	}
	
	public static class Sum extends Process
	{
		public Process p1;
		public Process p2;
		public Sum(Process P1,Process P2)
		{
			p1=P1;
			p2=P2;
			this.Type=ProcessType.Sum_tag;
		}
	}
	
	public static class Coop extends Process
	{
		public Process p1;
		public Process p2;
		public ActionSet l;
		public Coop(Process P1,ActionSet L,Process P2)
		{
			p1=P1;
			l=L;
			p2=P2;
			this.Type=ProcessType.Coop_tag;
		}
	}
	
	public static class Hide extends Process
	{
		public Process p;
		public ActionSet l;
		public Hide(Process P,ActionSet L)
		{
			p=P;
			l=L;
			this.Type=ProcessType.Hide_tag;
		}
	}
}