/*
 * WebAxe-3 workload for testing Web Accelerators (reverse proxies)
 *
 */

// Warning: These specs are under construction.
//          They are not pretty and have not been verified yet!


#include "contents.pg"
#include "phases.pg"
#include "benches.pg"

Bench TheBench = benchPolyMix3; // start with the default settings

TheBench.peak_req_rate = 300/sec;
rate PeakRate = TheBench.peak_req_rate;

// Fill rate (must be between 10% and 100% of peak request rate PeakRate)
rate FillRate = 75%*PeakRate;

// the two standard working set sizes are 100MB and 1GB
size WSS = 1GB;

// Cache size affects the duration of the "fill" phase below
// Use the sum of RAM and cache disks physical capacity
size CacheSize = 2GB + 1GB;

TheBench.client_addr_mask = '10.1.1.0';
TheBench.server_addr_mask = '10.1.1.0:80';
TheBench.max_client_load = 400/sec;
TheBench.client_host_count = clientHostCount(TheBench);

// robots and servers will bind to these addresses
//addr[] rbt_ips = robotAddrs(TheBench);
addr[] rbt_ips = ['10.1.1.1'];
addr[] srv_ips = ['10.1.1.2:80']; // set these manually!

/* internals */


// popularity model for the robots
PopModel popModel = {
	pop_distr = pmUnif();
	hot_set_frac =  1%;  // fraction of WSS (i.e., hot_set_size / WSS)
	hot_set_prob = 10%;  // prob. of req. an object from the hot set
};

// describe WebAxe-3 server
Server S = { 
	kind = "WebAxe-3-srv";

	contents      = [ cntImage: 65%, cntHTML: 15%, cntDownload: 0.5%, cntOther ];
	direct_access = [ cntHTML, cntDownload, cntOther ];

	xact_think = norm(0.3sec, 0.1sec);
	pconn_use_lmt = zipf(16);
	idle_pconn_tout = 15sec;

	hosts = srv_ips;
};

// describe WebAxe-3 robot
Robot R = {
	kind = "WebAxe-3-rbt";
	origins = srv_ips;

	recurrence      =   95%;
	embed_recur     =  100%;
	public_interest =   90%;
	pop_model = popModel;

	private_cache_cap = 1000; // number of objects in the private cache

	req_types = [ "IMS" : 10%, "Reload" : 5%, "Basic" ];

	req_rate = TheBench.max_robot_load;
	pconn_use_lmt = zipf(64);
	open_conn_lmt = 4;              // open connections limit

	hosts = rbt_ips;
};

int RobotCount = count(rbt_ips);

// XXX: we need to change launch algorithm to avoid magic
R.launch_win = RobotCount * 0.1sec;

// compute actual request rate
PeakRate = count(rbt_ips)*R.req_rate;


/* phases */

Phase phWarm = { 
	name = "warm"; 
	goal.duration = 2*R.launch_win;
	load_factor_beg = 0.1; 
	load_factor_end = FillRate/PeakRate;
	recur_factor_beg = 5%/95%;
	log_stats = false; 
};

Phase phFill = { 
	name = "fill";
	goal.fill_size = 2*CacheSize / TheBench.client_host_count;
	wait_wss_freeze = yes; // will finish only if WSS is frozen
};

Phase phLink1 = { 
        name = "link1";
        goal.duration = 5min;
        recur_factor_end = 1.0;
};

Phase phLink2 = { 
        name = "link2";
        goal.duration = 5min;
        load_factor_end = 1.0;
};

Phase phTop1 = { name = "top1"; goal.duration = 60min; };
Phase phDec  = { name = "dec";  goal.duration = 5min; load_factor_end = 0.1; };
Phase phIdle = { name = "idle"; goal.duration = 10min; };
Phase phInc  = { name = "inc";  goal.duration = 5min; load_factor_end = 1.0; };
Phase phTop2 = { name = "top2";	goal.duration = 60min; };

// build schedule using some well-known phases and phases defined above
schedule(phWarm, phFill, phLink1, phLink2,
	phTop1, phDec, phIdle, phInc, phTop2, 
	phCool);

working_set_cap(int(WSS/11KB/TheBench.client_host_count));

// commit to using these servers and robots
use(S, R);

// do not forget to configure network level delay and packet loss!
// client side: 100msec delay and 0.1% packet loss in both directions
// server side: no delays or packet losses.