# include	"user.h"
# include <math.h>
# define min(x,y) ((x < y) ? x : y )
# define max(x,y) ((x > y) ? x : y )

/*  This is a model of the C.MMP multiprocessor system adopted from Blake,
Reibman and Trivedi "Sensitivity Analysis of Reliability and
Performability Measures for Multiprocessor Systems", ACM SIGMETRICS 1988.
*/

int k;

extern int abs();
extern double pow();

parameters() {

	iopt(IOP_METHOD,VAL_TSUNIF);
	iopt(IOP_PR_FULL_MARK,VAL_YES);
	iopt(IOP_PR_MARK_ORDER,VAL_CANONIC);
	iopt(IOP_PR_MC_ORDER,VAL_TOFROM);
	iopt(IOP_MC,VAL_CTMC);
	iopt(IOP_PR_RSET,VAL_YES);
	iopt(IOP_PR_RGRAPH,VAL_YES);
	fopt(FOP_ABS_RET_M0,0.0);
	fopt(FOP_PRECISION,0.00000001);
	k = input("Please input min. number of proc. and mem. needed");
	if ( k < 1 )
	{
	   fprintf(stderr,"ERROR: atleast one processor is needed (k > 1)");
	   exit(1);
	}

}

enabling_type entrflr() {
			if ( mark("procup") == 0 &&
			   mark("memup") == 0 &&
			   mark("swup") == 0 )
			   return(0);
			if ( mark("procup") < k ||
			   mark("memup") < k ||
			   mark("swup") == 0 )
			   return(1);
		  	else
			return(0); }

int apfl() { return( mark("procup"));}
int amfl() { return( mark("memup"));}
int asfl() { return( mark("swup"));}

net() {
	place("procup");
	init("procup",16);
	place("procdn");
	place("memup");
	init("memup",16);
	place("memdn");
	place("swup");
	init("swup",1);
	place("swdn");

	trans("trpr");
	trans("trmm");
	trans("trsw");
	trans("trflr");
	priority("trflr",100);
	enabling("trflr",entrflr);

	ratedep("trpr",0.0000689,"procup");
	ratedep("trmm",0.000224,"memup");
	rateval("trsw",0.0002202);
	probval("trflr",1.0);

	iarc("trpr","procup");	oarc("trpr","procdn");
	iarc("trmm","memup");	oarc("trmm","memdn");
	iarc("trsw","swup");	oarc("trsw","swdn");
	viarc("trflr","procup",apfl);	voarc("trflr","procdn",apfl);
	viarc("trflr","memup",amfl);	voarc("trflr","memdn",amfl);
	viarc("trflr","swup",asfl);	voarc("trflr","swdn",asfl);

}

assert() {
}

ac_init() {
	fprintf(stderr,"\nC.MMP Reliability Model\n\n");
	pr_net_info();
}

ac_reach() {
	pr_rg_info();
}

reward_type reliab() {
	 if ( mark("procup") >= k && mark("memup") >= k && mark("swup") == 1 )
        return(1.0);
	 else
		return(0.0); }

reward_type reward_rate() {

	double m, l, temp;
			     
	if ( mark("procup") >= k && mark("memup") >= k && mark("swup") == 1 )
	{
		l = min((double)mark("procup"),(double)mark("memup"));
		m = max((double)mark("procup"),(double)mark("memup"));
		temp = pow( (1.0 - (1.0 / m)) , l );
        return( m * (1.0 - temp) );
	}
	else
		return(0); }

ac_final() {
	double time_pt;
	for ( time_pt = 500.0; time_pt < 5000.0; time_pt+= 500.0 )
	{
		time_value( time_pt );
		pr_expected("Reliability",reliab);
		pr_expected("Expected Reward",reward_rate);
		pr_cum_expected("Expected Accumulated Reward",reward_rate);
	}
}