/* This example computes the conditional response time distribution for a closed
queueing network model shown in the accompanying document */
# include	"user.h"

#define max(x,y) ((x>y)?(x):(y))
#define min(x,y) ((x<y)?(x):(y))

double lambda, mucpu, mudisk,p1;
int nterm, ncpu, ndisk;

parameters() {

	iopt(IOP_USENAME,VAL_NO);
	iopt(IOP_METHOD,VAL_TSUNIF);
	iopt(IOP_MC,VAL_CTMC);
	iopt(IOP_PR_MARK_ORDER,VAL_CANONIC);
	iopt(IOP_PR_MC_ORDER,VAL_TOFROM);
	iopt(IOP_PR_MC,VAL_NO);
	iopt(IOP_PR_PROB,VAL_NO);
	iopt(IOP_PR_RSET,VAL_YES);
	iopt(IOP_PR_RGRAPH,VAL_YES);
	iopt(IOP_ITERATIONS,20000);
	iopt(IOP_CUMULATIVE,VAL_NO);
	fopt(FOP_ABS_RET_M0,0.0);
	fopt(FOP_PRECISION,0.00000001);

	nterm = input("number of terminals");
	ncpu = input("number of cpus");
	ndisk = input("number of disks");
	lambda = 5.0;
	mucpu = 50.0;
	mudisk = 20.0;
	p1 = 0.80;

}

enabling_type enall() { return( 1.0 - mark("ptfin")); }

enabling_type entcoi() { if ((mark("ptcpuq") == 0 ||
			      mark("pcpuq") < ncpu - 1 ) &&
			      mark("ptfin") == 0)
				return(1);
			 else
			    return(0); }

enabling_type entdoi() { if ((mark("ptdq") == 0 ||
			      mark("pdq") < ndisk - 1 ) &&
			      mark("ptfin") == 0)
				return(1);
			 else
			    return(0); }

enabling_type enttcpu() { if ( mark("pcpuq") < ncpu &&
			       mark("ptfin") == 0)
			       return(1);
			   else
			      return(0); }

enabling_type enttdisk() { if ( mark("pdq") < ndisk &&
			       mark("ptfin") == 0)
			       return(1);
			   else
			      return(0); }

rate_type rate_tcpu() { return( min(mark("pcpuq"),ncpu)*mucpu ); }

rate_type rate_tdisk() { return( min(mark("pdq"),ndisk)*mudisk ); }

/* variable cardinality arcs */
int arctdoi() { if ( mark("ptdq") == 1) return(1);
		else return(max(1,mark("pdqo")));}

int arctcoi() { if ( mark("ptcpuq") == 1) return(1);
		else return(max(1,mark("pcpuqo")));}

net() {

	place("pterm");
	init("pterm",nterm);
	place("pcpuqo");
	place("pcpuq");
	place("pbrch");
	place("pdqo");
	place("pdq");

	place("ptcpuq");
	init("ptcpuq",1);
	place("ptbr");
	place("ptdq");
	place("ptfin");

	trans("tterm");
	enabling("tterm",enall);
	trans("tcoi");
	priority("tcoi",50);
	enabling("tcoi",entcoi);
	trans("tcpu");
	enabling("tcpu",enall);
	trans("tct");
	priority("tct",100);
	enabling("tct",enall);
	trans("tcd");
	priority("tcd",100);
	enabling("tcd",enall);
	trans("tdoi");
	priority("tdoi",50);
	enabling("tdoi",entdoi);
	trans("tdisk");
	enabling("tdisk",enall);

	trans("ttcpu");
	enabling("ttcpu",enttcpu);
	trans("ttco");
	priority("ttco",100);
	enabling("ttco",enall);
	trans("ttcd");
	priority("ttcd",100);
	enabling("ttcd",enall);
	trans("ttdisk");
	enabling("ttdisk",enttdisk);

	ratedep("tterm",lambda,"pterm");
	probval("tcoi",1.0);
	ratefun("tcpu",rate_tcpu);
	probval("tcd",p1);
	probval("tct",1.0 - p1);
	probval("tdoi",1.0);
	ratefun("tdisk",rate_tdisk);

	rateval("ttcpu",mucpu);
	probval("ttcd",p1);
	probval("ttco",1.0 - p1);
	rateval("ttdisk",mudisk);

	iarc("tterm","pterm");	oarc("tterm","pcpuqo");
	viarc("tcoi","pcpuqo",arctcoi);  voarc("tcoi","pcpuq",arctcoi);
	iarc("tcpu","pcpuq");	oarc("tcpu","pbrch");
	iarc("tct","pbrch");	oarc("tct","pterm");
	iarc("tcd","pbrch");	oarc("tcd","pdqo");
	viarc("tdoi","pdqo",arctdoi);  voarc("tdoi","pdq",arctdoi);
	iarc("tdisk","pdq");	oarc("tdisk","pcpuq");

	iarc("ttcpu","ptcpuq");	oarc("ttcpu","ptbr");
	iarc("ttco","ptbr");	oarc("ttco","ptfin");
	iarc("ttcd","ptbr");	oarc("ttcd","ptdq");
	iarc("ttdisk","ptdq");	oarc("ttdisk","ptcpuq");

}

assert() {
		return(RES_NOERR);
}

ac_init() {
	pr_net_info();
}

ac_reach() {
	pr_rg_info();
}

reward_type	ef0() { return(mark("ptfin")); }

ac_final() {
	double time_point;

	pr_mc_info();

	for ( time_point = 0.02; time_point < 0.2; time_point += 0.02)
	{
	   time_value( time_point );
	   pr_expected("response time",ef0);
	}
	for ( time_point = 0.2; time_point < 1.0; time_point += 0.2)
	{
	   time_value( time_point );
	   pr_expected("response time",ef0);
	}
	for ( time_point = 1.0; time_point < 10.0; time_point += 1.0)
	{
	   time_value( time_point );
	   pr_expected("response time",ef0);
	}
	for ( time_point = 10.0; time_point < 20.0; time_point += 5.0)
	{
	   time_value( time_point );
	   pr_expected("response time",ef0);
	}

}