[squid-users] squid + epoll polygraph test

Hello All,

    I am preparing epoll() I/O method benchmarking with Polygraph (Polygraph 2.5.5) with setup as,

        squid + epoll():
        Linux host 2.6.5-1.358 #1 i686 athlon i386 GNU/Linux
        Squid Cache: Version 3.0-PRE3
        configure options: '--prefix=/home/muthu/squidepoll' '--enable-epoll' '--with-aufs-threads=32' '--with-descriptors=32768'
'--with-pthreads'
        '--enable- storeio=null,ufs,aufs' '--disable-poll' '--disable-select' '--disable-kqueue'

        Polygraph server-1:
        Linux host 2.4.18-14 #1 i686 i686 i386 GNU/Linux
        Polygraph 2.5.5

        Polygraph client-1:
        Linux host 2.4.18-14 #1 i686 i686 i386 GNU/Linux
        Polygraph 2.5.5

        Is there anyone benchmarked squid+epoll() on polygraph? How may I expect requests satisfaction limit on Linux host
2.6.5-1.358 #1 i686 athlon i386 GNU/Linux platform?

        During polygraph testing, I am getting errors as,
        004.03| ./Xaction.cc:79: error: 1/1 (267) unsupported HTTP status code
        004.03| ./Xaction.cc:79: error: 2/2 (267) unsupported HTTP status code

        --- Polygraph configuration --

Bench benchPolyMix3 = {
peak_req_rate = undef(); // must be set

client_addr_mask = '10.1.0.0'; // may be adjusted
server_addr_mask = '10.1.0.0:18256'; // may be adjusted

max_client_load = 800/sec; // maximum load per Polygraph PC
max_robot_load = 0.4/sec; // maximum robot request rate

client_host_count = undef(); // number of polyclts in the bench
};

ObjLifeCycle olcStatic = {
birthday = now + const(-1year); // born a year ago
length = const(2year); // two year cycle
variance = 0%; // no variance
with_lmt = 100%; // all responses have LMT
expires = [nmt + const(0sec)]; // everything expires when modified
};

ObjLifeCycle olcHTML = {
birthday = now + exp(-0.5year); // born about half a year ago
length = logn(7day, 1day); // heavy tail, weekly updates
variance = 33%;
with_lmt = 100%; // all responses have LMT
expires = [nmt + const(0sec)]; // everything expires when modified
};

ObjLifeCycle olcImage = {
birthday = now + exp(-1year); // born about a year ago
length = logn(30day, 7day); // heavy tail, monthly updates
variance = 50%;
with_lmt = 100%; // all responses have LMT
expires = [nmt + const(0sec)]; // everything expires when modified
};

// object life cycle for "Download" content
ObjLifeCycle olcDownload = {
birthday = now + exp(-1year); // born about a year ago
length = logn(0.5year, 30day); // almost no updates
variance = 33%;
with_lmt = 100%; // all responses have LMT
expires = [nmt + const(0sec)]; // everything expires when modified
};

// object life cycle for "Other" content
ObjLifeCycle olcOther = {
birthday = now + exp(-1year); // born about half a year ago
length = unif(1day, 1year);
variance = 50%;
with_lmt = 100%; // all responses have LMT
expires = [nmt + const(0sec)]; // everything expires when modified
};

// PolyMix-1 content
Content cntPolyMix_1 = {
kind = "polymix-1"; // just a label
mime = { type = undef(); extensions = []; };
size = exp(13KB);
obj_life_cycle = olcStatic;
cachable = 80%;
};

Content cntImage = {
kind = "image";
mime = { type = undef(); extensions = [ ".gif", ".jpeg", ".png" ]; };
obj_life_cycle = olcImage;
size = exp(4.5KB);
cachable = 80%;
};

Content cntHTML = {
kind = "HTML";
mime = { type = undef(); extensions = [ ".html" : 60%, ".htm" ]; };
obj_life_cycle = olcHTML;
size = exp(8.5KB);
cachable = 90%;
may_contain = [ cntImage ];
embedded_obj_cnt = zipf(13);
};

Content cntDownload = {
kind = "download";
mime = { type = undef(); extensions = [ ".exe": 40%, ".zip", ".gz" ]; };
obj_life_cycle = olcDownload;
size = logn(300KB, 300KB);
cachable = 95%;
};

Content cntOther = {
kind = "other";
obj_life_cycle = olcOther;
size = logn(25KB, 10KB);
cachable = 72%;
};

Phase phWait = { name = "wait"; goal.xactions = 1; log_stats = false; };

Phase phCool = { name = "cool"; goal.duration = 1min; load_factor_end = 0; log_stats = false; };

Bench TheBench = benchPolyMix3; // start with the default settings
TheBench.peak_req_rate = 200/sec;
size ProxyCacheSize = 12GB;
rate FillRate = 90%*TheBench.peak_req_rate;

TheBench.client_host_count = clientHostCount(TheBench);

// robots and servers will bind to these addresses
addr[] rbt_ips = robotAddrs(TheBench); // or ['127.0.0.1' ** 2 ];
addr[] srv_ips = serverAddrs(TheBench); // or ['127.0.0.1:8080', '127.0.0.1:8888' ];

// 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 PolyMix-3 server
Server S = {
kind = "PolyMix-3-srv";

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

xact_think = norm(2.5sec, 1sec);
pconn_use_lmt = zipf(16);
idle_pconn_tout = 15sec;

hosts = srv_ips;
};

float HitIfRepeat = 80% * (100% - 5%);

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

recurrence = 55%/HitIfRepeat; // recurrence is not hit ratio
embed_recur = 100%;
public_interest = 50%;
private_cache_cap = 1000; // number of objects in the private cache

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

pop_model = popModel;

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

hosts = rbt_ips;
};

int RobotCount = count(R.hosts);

// re-compute peak request rate
rate PeakRate = RobotCount * R.req_rate;

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

/* phases */

time platDur = 15min; // plateau phases duration (except idle phase)
time rampDur = platDur/8; // ramp phases duration (and idle phase)

// limit the growth of the URL "working set" size (WSS)
float fillable_ratio = 75%; // ~(cachable, not reloaded, HTTP 200 response)
rate peak_fill_rate = PeakRate * 0.45 * fillable_ratio;
int wsc = int(peak_fill_rate * platDur); // number of objects in the WS
working_set_cap(wsc / TheBench.client_host_count);

Phase phWarm = {
name = "warm";
goal.duration = R.launch_win;
recur_factor_beg = 5%/55%;
special_req_factor_beg = 0.1;
load_factor_beg = 0.1;
log_stats = false;
};

Phase phFRamp = {
name = "framp";
goal.duration = rampDur;
load_factor_end = FillRate/PeakRate;
};

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

Phase phFExit = {
name = "fexit";
goal.duration = rampDur;
recur_factor_end = 1;
        special_req_factor_end = 1;
load_factor_end = 0.1;
};

Phase phInc1 = {
name = "inc1";
goal.duration = rampDur;
recur_factor_end = 1;
        special_req_factor_end = 1;
load_factor_end = 1.0;
};

Phase phTop1 = { name = "top1"; goal.duration = platDur; };
Phase phDec1 = { name = "dec1"; goal.duration = rampDur; load_factor_end = 0.1; };

Phase phIdle = { name = "idle"; goal.duration = rampDur; };

Phase phInc2 = { name = "inc2"; goal.duration = rampDur; load_factor_end = 1.0; };
Phase phTop2 = { name = "top2"; goal.duration = platDur; };
Phase phDec2 = { name = "dec2"; goal.duration = rampDur; load_factor_end = 0.1; };

/* collect stats samples in the middle of plateau phases */
StatsSample topSample = { capacity = 10000; };
StatsSample fillSample = { capacity = int(10% * topSample.capacity); };

phFill.stats_samples = [ fillSample ];
phTop1.stats_samples = [ topSample ];
phTop2.stats_samples = [ topSample ];

// build schedule using some well-known phases and phases defined above
schedule(
phWarm,
// phFRamp,
// phFill, phFExit,
phInc1, phTop1, phDec1,
// phIdle,
// phInc2, phTop2, phDec2,
phCool
);

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

    --------------------------

    Can any one share your polygraph testings? Thanks for your help.

Regards
Muthu

---
===============  It is a "Virus Free Mail" ===============
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.786 / Virus Database: 532 - Release Date: 10/29/2004