webâ€“server systems htcpns-based development tool application in

e-Informatica Software Engineering Journal, Volume 3, Issue 1, 2009

Web–Server Systems HTCPNs-BasedDevelopment Tool Application in

Load Balance Modelling

Slawomir Samolej∗, Tomasz Szmuc∗∗∗Department of Computer and Control Engineering, Rzeszów University of Technology

∗∗Institute of Automatics, AGH University of Science and [email protected], [email protected]

AbstractA new software tool for web–server systems development is presented. The tool consist of a setof predefined Hierarchical Timed Coloured Petri Net (HTCPN) structures – patterns. The pat-terns make it possible to naturally construct typical and experimental server–systems structures.The preliminary patterns are executable queueing systems. A simulation based methodology ofweb–server model analysis and validation has been proposed. The paper focuses on presenting theconstruction of the software tool and its application for selected cluster–based web–servers loadbalancing strategies evaluation.

1. Introduction

Gradually, the Internet becomes the most im-portant medium for conducting business, sell-ing services and remote control of industrialprocesses. Typical modern software applicationshave a client–server logical structure where pre-dominant role plays an Internet server offer-ing data access or computation abilities for re-mote clients. The hardware of an Internet orweb–server is now usually designed as a set of(locally) deployed computers. The computersare divided into some layers or clusters whereeach layer executes separate web–system task[4], [12], [24], [34], [39], [37], [5], [2], [22], [9], [29],[23]. This design approach makes it possible todistribute services among the nodes of a clusterand to improve the scalability of the system. Re-dundancy which intrinsically exists in such hard-ware structure provides higher system depend-ability. Fig. 1 shows an example cluster–basedInternet system structure. The Internet requestsare generated by the clients. Then they are dis-tributed by the load balancer among set of com-

puters that constitute the front-end or WWWcluster. The front–end cluster offers a systeminterface and some procedures that optimizethe load of the next system layer–the databaseserver.

To improve the quality of service ofweb–server clusters two main research pathsare followed. First, the software of individualweb–server nodes is modified to offer averageresponse time to dedicated classes of consumers[11], [18], [19]. Second, some distribution strate-gies of cluster nodes are investigated [4], [29] inconjunction with searching for load balancingpolicies for the nodes [6], [32], [39], [37], [5], [2],[22]. In several research projects reported in [12],[30], [34] load balancing algorithms and modifiedcluster node structures are analyzed together.

It is worth noticing that in some of above-mentioned manuscripts searching for a solutionof the problem goes together with searching forthe adequate formal language to express thesystem developed [3], [12], [30], [32], [34], [39].In [3], [32], [34], [39] Queueing Nets whereasin [30] Stochastic Petri Nets are applied for

140 Slawomir Samolej, Tomasz Szmuc

Figure 1. Example distributed cluster–based Internet system

system model construction and examination.However, the most mature and expressive lan-guage proposed for the web–cluster modellingseems to be Queueing Petri Nets (QPNs) [12].The nets combine coloured and stochastic Petrinets with queueing systems [1] and consequentlymake it possible to model relatively complexweb–server systems in a concise way. Moreover,there exists a software tool for the nets sim-ulation [13]. The research results reported in[12] include a systematic approach to apply-ing QPNs in distributed applications modellingand evaluation. The modelling process has beendivided into following stages: system compo-nents and resources modelling, workload mod-elling, intercomponent interactions and process-ing steps modelling, and finally – model param-eterization. The final QPNs based model can beexecuted and used for modelled system perfor-mance prediction.

The successful application of QPNs inweb–cluster modelling become motivation to re-search reported in this paper. The aim of theresearch is to provide an alternative methodol-ogy and software tool for cluster–based hard-ware/software systems development. The mainfeatures of the methodology are as follows:– The modelling language will be Hierarchical

Timed Coloured Petri Nets (HTCPNs) [7],– A set of so called HTCPNs design patterns

(predefined net structures) will be preparedand validated to model typical web clustercomponents,

– The basic patterns will be executable modelsof queueing systems,

– A set of design rules will be provided to copewith the patterns during the system modelcreation,

– The final model will be an executable and an-alyzable Hierarchical Timed Coloured PetriNet,

– A well established Design/CPN and CPNTools software toolkits will be used for thedesign patterns construction and validation,

– The toolkits will also be used as a platformfor the web–server modelling and develop-ment,

– Performance analysis modules of the toolkitswill be used for capturing and monitoring thestate of the net during execution.The choice of HTCPNs formalism as a mod-

elling language comes from the following pre-requisites. First, HTCPNs have an expressionpower comparable to QPNs. Second, the avail-able software toolkits for HTCPNs composi-tion and validation seem to be more popu-lar than“SimQPN” [13]. Third, there exists areach knowledge base of successful HTCPNsapplications to modelling and validation ofwide range software/hardware systems [7] in-cluding web–servers [24], [27], [36]. The restnamed features of design methodology intro-duced in this paper results from both gen-erally known capabilities of software toolkitsfor HTCPNs modelling and some previous ex-perience gained by the authors in applica-

Web–Server Systems HTCPNs-Based Development Tool Application in Load Balance Modelling 141

tion HTCPNs to real–time systems develop-ment [25], [26].

This paper is organized as follows. Section2 describes some selected design patterns andrules of applying them to web–server clustermodel construction. An example queueing sys-tem, web–server subsystem and top–level sys-tem models are presented. Then the simulationbased HTCPNs models validation methods arediscussed. Section 3 presents HTCPNs models ofselected experimental and applied load balanc-ing strategies for computer clusters. The loadbalancing models construction and some simu-lation results are discussed. Conclusions and fu-ture research program complete the paper.

It has been assumed that the reader is fa-miliar with the basic principles of HierarchicalTimed Coloured Petri Nets theory [7], [8], [14].All the Coloured Petri Nets in the paper havebeen edited and analysed using Design/CPNtool [21], [36]. Equivalent HTCPNs models maybe developed using CPN Tools [8], [35] softwaretoolkit.

2. Cluster Server ModellingMethodology

The main concept of the methodology lies in thedefinition of reusable timed coloured Petri netsstructures (patterns) making it possible to com-pose web–server models in a systematic manner.The basic set of the patterns includes typicalqueueing systems TCPNs implementations, eg.–/M/PS/∞ , –/M/FIFO/∞ [24], [27]. Packetdistribution TCPNs patterns constitute the nextgroup of reusable blocks. They preliminary roleis to provide some predefined web–server clus-ter substructures composed from the queueingsystems. At this stage of subsystem modellingthe queueing systems are represented as sub-stitution transitions (compare [24], [27]). Theseparate models of system arrival processes arealso the members of the group mentioned. Thepacket distribution patterns represented as sub-stitution transitions are in turn used for the gen-eral top–level system model composition. As aresult, the 3–level web–server model composi-

tion has been proposed. The top–level TCPNrepresents the general view of system compo-nents. The middle–level TCPNs structures rep-resent the queueing systems interconnections.And the lowest level includes executable queue-ing systems implementations.

The modelling methodology assumes, thatthe actual state of the Internet requests servic-ing in the system can be monitored. Moreover,from the logical point of view the model of theserver cluster is an open queueing network, sothe requests are generated, serviced and finallyremoved from the system. As a result an impor-tant component of the software tool for servercluster development is the logical representationof the requests.

In the next subsections the following featuresof the modelling methodology will be explainedin detail. First, the logical representation of In-ternet requests will be shown. Second, queueingsystem modelling rules will be explained. Third,an example cluster subsystem with an individ-ual load–balancing strategy will be proposed.Fourth, Internet request generator structure willbe examined. Fifth, top–level HTCPNs struc-ture of an example cluster–server model will beshown. Finally, model analysis capabilities willbe discussed.

2.1. Logical Request Representation

In the server–cluster modelling methodologythat is introducing in the paper the structureof the HTCPN represents a hardvare/softwarearchitecture of web–server. Yet, the dynamics ofthe modelled system behavior is determined bystate and allocation of tokens in the net struc-ture. Two groups of tokens has been proposed formodel construction. The first group consists ofthe so–called local tokens, that “live” in individ-ual design patters. They provide local functionsand data structures for the patterns. The sec-ond group of tokens represents Internet requeststhat are serviced in the system. They are trans-ported throughout several cluster components.Their internal state carries data that may beused for timing and performance evaluation ofthe system modelled. As the tokens represent-


ing the requests have the predominant role inthe modelling methodology, they structure willbe explained in detail.

Each token representing an Internet requestis a tuple

PACKAGE = (ID,PRT ,START_TIME ,PROB,AUTIL,RUTIL),

where ID is a request identifier, PRT is a requestpriority, START_TIME is a value of simula-tion time when the request is generated, PROBis a random value, AUTIL is an absolute requestutilization value, and RUTIL is a relative re-quest utilization value. Request identifier makesit possible to give the request an unique number.Request priority is an integer value that maybe taken into consideration when the requestsare scheduled according priority driven strategy[11]. START_TIME parameter can store a sim-ulation time value and can be used for the tim-ing validation of the requests. Absolute requestutilization value, and relative request utilizationvalue are exploited in some queueing systemsexecution models (e.g. with processor sharingservice).

2.2. Queueing System Models

The basic components of the software tool forweb–server clusters development introduced inthis paper are the executable queueing systemsmodels. At the current state of the software toolconstruction the queueing systems models canhave FIFO, LIFO, processor sharing or prior-ity based service discipline. For each queue anarbitrary number of service units may be de-fined. Additionally, the basic queueing systemshas been equipped with auxiliary componentsthat are responsible for monitoring of internalstates of the queue during its execution.

An example HTCPNs based –/1/FIFO/∞queueing system model is shown in Fig. 2.The model is a HTCPNs subpage thatcan communicate with the parent page viaINPUT_PACKS , OUTPUT_PACKS and QLport places. Request packets (that arrivethrough INPUT_PACK place) are placedinto a queue structure within PACK_QUEUE

place after ADD_FIFO transition execution.TIMERS place and REMOVE_FIFO transi-tion constitute a clock–like structure and areused for modelling of duration of packet exe-cution. When REMOVE_FIFO transition fires,then the first packet from the queue is with-drawn and directed to the service procedure.

The packets under service acquire the ade-quate time stamps generated according to theassumed service time random distribution func-tion. The time stamps associated with thetokens prevent from using the packet tuples(the tokens) for any transition firing until thestated simulation time elapses (according to fir-ing rules defined for HTCPNs [7]). The pack-ets are treated as serviced when they can leaveOUTPUT_PACKS place as their time stampsexpired. The number of tokens in TIMERS placedefines the quantity of queue servicing units inthe system.

Main parameters that define the queueingsystem model dynamics are queue mean servicetime, service time probability distribution func-tion and number of servicing units. Capacity ofthe queue is not now taken into considerationand theoretically may be unlimited.

For future applications the primary queue-ing system design pattern explained above hasbeen equipped with an auxiliary “plug–in”.COUNT_QL transition and TIMER_QL, QLand COUNTER places make it possible to mea-sure the queue length and export the mea-sured value to the parent CPNs page duringthe net execution. TIMER_QL place includesa timer token that can periodically enable theCOUNT_QL transition. QL port place includesa token storing the last measured queue lengthand an individual number of a queueing systemin the system. The COUNTER place includes acounter token used for the synchronization pur-pose.

2.3. Packet Distribution Models

Having a set of queueing systems design pat-terns some packet distribution HTCPNs struc-tures may be proposed. In [24] a typical ho-mogeneous multi–tier web–server structure pat-


ADD_FIFO

PACK_QUEUE

PACK_QUEUE

nil REMOVE_FIFO

[fifo_queue<>nil]

C

output (tim_val);actiondiscExp(1.0/fifo1_ser_mean_time);

TIMERS TIMER1‘1

OUTPUT_PACKS

PACKAGE

P Ge

INPUT_PACKS

PACKAGE

P Ge

QLQL_A_ID

P Ge

TIMER_QL

TIMER1‘1

COUNT_QL

COUNTERINT

1‘0

FGFifo queue

pack

add_FIFO(pack,fifo_queue)

fifo_queue

fifo_queue release_FIFO(fifo_queue)@+tim_val

update_FIFO(fifo_queue)

fifo_queue

1‘(length fifo_queue,#2 qlen_a_id)

qlen_a_id

tim1

1‘tim1@+ql_timer_val

1‘tim1@+tim_val1‘tim1

n

n+1

Figure 2. HTCPNs based –/1/FIFO/∞ queueing system model

T3

T4

T5

PACKS3

PACKAGE

PACKS4

PACKAGE

PACKS5

PACKAGE

FIFO1

HS

FIFO2

HS

FIFO3

HS

PACKS8

PACKAGE

PACKS9

PACKAGE

PACKS10

PACKAGE

T8

T9

T10

PACKS13

PACKAGE

P Out

PACKS1

PACKAGE

P In

Load Balacer Server Cluster

pack

pack

pack

pack

pack

pack

pack

pack

pack pack

pack

pack

pack

pack

pack

pack

pack

pack

Figure 3. WWW cluster with stochastic load balancer

tern was examined, in [23] a detailed distributeddatabase cluster model was proposed, whereasin [27] a preliminary version of server structurewith feedback like admission control of Inter-net requests was introduced. The packet dis-tribution patterns presented in this paper arealso related to the load balancing in web–servercluster problem. The detailed discussion of someselected load balancing strategies models is in-cluded in section 3. In this section a simpleWWW cluster model with stochastic packed dis-tribution policy is concerned.

Figure 3 includes an example of clus-ter load–balancing HTCPNs model. The clus-

ter consists of 3 computers (compare Fig. 1)represented as FIFO1 . . .FIFO3 substitutiontransitions, where each transition is attachedto the corresponding FIFO queueing pat-tern. The Internet requests serviced by thecluster arrive through PACKS1 port place.A load balancer decides where the cur-rently acquired request should be send. Whena token arrives in PACKS1 place, transi-tions T3 . . .T5 are in conflict. According toCPN properties, a transition is randomlychosen for firing. Consequently, the stochas-tic packet distribution policy is naturallymodelled.


2.4. Request Generator Model

According to one of main assumptions of theweb–server cluster modelling methodology pre-sented in this paper, the system model can betreated as an open queueing network. Conse-quently, the crucial model component must be anetwork arrival process simulating the Internetservice requests that are sent to the server.

Figure 4 shows an example HTCPNs sub-page that models a typical Internet request gen-erator. The core of the packet generator is aclock composed from TIMER0 place and T0transition. The code segment attached to theT0 transition produces values of time–stampsfor tokens stored in TIMER0 place. The valuesare defined by the defined probability function.As a result the Internet requests appear intoPACKS1 place at random moments in simula-tion time. The frequency at which tokens ap-pear in PACKS1 place is determined by thementioned above distribution function. PACKS1place has a port place status and thereafter to-kens appearing in it can be consumed by othermodel components (e.g. server cluster model).

T0C

output (tim_val);actiondiscExp(1.0/pack_gen_mean_time);

COUNT0

INT 1‘1

TIMER0

TIMER 1‘1

PACKS1

PACKAGE

P Getim1

tim1@+tim_val

(n,1,intTime(),ran’random_val(),0,0)n

n+1

Figure 4. Web–server arrival process model

The Internet request frequency can have anystandard probability distribution function orcan be individually constructed as it was pro-posed in [36].

2.5. Example Top–Level Multi–TierServer Model

Having the adequate set of design patterns, awide area of server cluster architectures can be

modelled and tested at the early stage of de-velopment process. At the top–level modellingprocess each of the main components of the sys-tem can be represented as a HTCPNs substitu-tion transition. The modelling methodology pre-sented in the paper suggest that at the top–levelmodel construction the arrival process and mainserver cluster layers should be highlighted. Af-ter that each of the main components (mainsubstitution transition) should be decomposedinto an adequate packed distribution subpage,were under some of transitions queueing systemmodels will be attached. It is easily to noticethat a typical top–down modelling approach ofsoftware/hardware system modelling has beenadapted in the web server modelling methodol-ogy proposed in the paper.

Figure 5 includes an example top–levelHTCPN model of cluster–based server (com-pare Fig. 1) that follows the abovementionedmodelling development rules. The HTCPNin Fig. 5 consists of 3 substitution transi-tions. Input_Procs transition represents thearrival process for the server cluster, whereasWWW_Server_Cluster transition representsthe first–layer of multi–tier web–server, and fi-nally DataBaseServer transition represents thedata base server.

The modelling process can be easily ex-tended by attaching the request generator modelas in section 2.4 under the Input_Procs transi-tion and by attaching the WWW cluster modelwith load balancing module as in section 2.3underWWW_Server_Cluster transition. Thefinal executable model can be acquired by at-taching FIFO design patterns under FIFO1,FIFO2 and FIFO3 transitions in the load bal-ancing module (compare sections 2.2 and 2.3).A separate model should be proposed for thepacket distribution and queueing models layersof the data base server.

2.6. Model Validation Capabilities

Typical elements of HTCPNs modelling soft-ware tools are performance evaluation routines,e.g.: [16], [35] . The routines make it possible tocapture the state of dedicated tokens or places


PACKS1

PACKAGE

PACKS18

PACKAGE

T13

Input_Procs WWW_Server_Cluster DataBaseServer

PACKS13

PACKAGE

Figure 5. Example top–level multi–tier server model

during the HTCPN execution. A special kindof log files showing the changes in the state ofHTCPN can be received and analyzed offline.

At the currently reported version ofweb–server cluster modelling and analysis soft-ware tool, queue lengths and service timelengths can be stored during the model ex-ecution. Detecting the queue lengths seemsto be the most natural load measure avail-able in typical software systems. The servicetime lengths are measurable in the proposedmodelling method because of a special kindPACKAGE type tokens construction (comparesection 2.1). The tokens “remember” the simu-lation time at which their appear in the clusterand thereafter the time at each state of theirservice may be captured. In real systems theservice time is a predominant quality of serviceparameter for performance evaluation.

The performance analysis of models of webservers constructed according the proposed inthe paper methodology can be applied in thefollowing domains.

First, the system instability may be easilydetected. The stable or balanced queueing sys-tem in a steady state has an approximately con-stans average queue length and correspondinglyaverage service time. On the contrary, when thearrival process is to intensive for the queueingsystems to serve, both queue lengths and servicetimes increase. This kind of analysis is possiblewhen there are no limitations for queue lengthsin the proposed modelling method. Fig. 6 showsthe queue lengths (Fig. 6 (left)) and service timelengths (Fig. 6 (right)) when the considered webserver cluster model is permanently overloaded.

Second, the average values of queueing sys-tem systems parameters such as average queuelengths and average servicing times for the bal-

anced model can be estimated. Provided thatthe arrival process model and the server nodesmodels parameters are acquired from the realdevices as in [18], [30], [34], [36], the softwaremodel can be used for derivation the systemproperties under different load conditions. In theFig. 7 queue lengths (Fig. 7 (left)) and servicetimes (Fig. 7 (right)) under stable system execu-tion are shown. The cluster had a heterogeneousstructure, where server 2 (FIFO2 model) had4 times lower performance. FIFO1 and FIFO3average queue length was 1.7, whereas FIFO3queue length was 4.4. The average service timefor FIFO1 and FIFO3 cluster nodes was 811time units whereas for FIFO2 was 7471 timeunits.

Third, some individual properties of clusternode structures or load balancing strategies maybe observed. Some selected load balancing algo-rithms properties derived from simulation exper-iments will be discussed in section 3.

3. Example of Load BalancingStrategies Evaluation

Load balancing is an important issue in paralleland distributed systems. In traditional computa-tion systems load balancing procedures were usedto distribute the computation task among systemnodes. It improved the general system utilisationand usually led to faster processing. In recentyears, the load balancing algorithms elaboratedfor general parallel and distributed systems [31]were naturally re-applied in the emerging locallydistributed Internet or web systems. The firstload balancing strategies successively applied inInternet systems were static random distributionpolicy [28] and static modulus-based round-robin


0 100 200 300 400 500 600 700 800 900

0 500000 1e+06 1.5e+06 2e+06 2.5e+06

Que

ue L

engt

h

Time [sim. time units]

Queue 1,2,3 Lengths

Fifo1_lengthFifo2_lengthFifo3_length

0 100000 200000 300000 400000 500000 600000 700000 800000 900000

0 500000 1e+06 1.5e+06 2e+06 2.5e+06

Ser

vice

Tim

e Le

ngth


Service Time Lengths

Server 1 serv. len.Server 2 serv. len.Server 3 serv. len.

Figure 6. Queue lengths (left) and service times (right) under overload condition

0

2

4

6

8

10

12

0 500000 1e+06 1.5e+06 2e+06 2.5e+06

Que

ue L

engt

h


Queue 1,2,3 Lengths


0

5000

10000

15000

20000

25000

30000

0 500000 1e+06 1.5e+06 2e+06 2.5e+06

Ser

vice

Tim

e Le

ngth


Service Time Lengths

Server 1 serv. len.Server 2 serv. len.Server 3 serv. len.

Figure 7. Queue lengths (left) and service times (right) under stable system execution

policy [15]. There were described in the paper[38] successful implementations of round-robin,weighted round-robin, least-connection andweight least-connection load balancing strate-gies in Linux Virtual Server [17] . The abovemen-tioned strategies are now standard algorithmsin commercial load balancing solutions as men-tioned in [20], [33].

The rapid development of web–server ori-ented load balancing policies was tentativelysystematised in [5], [2]. Paper [5] classi-fies distributed web-server architectures re-garding the entity which distributes requestsamong servers. It defines 4 approaches of re-quest distribution: client–based, DNS–based,dispatcher–based, and server–based. In [2] an at-tempt of simulation based on comparison of se-lected load balancing algorithms such as “roundrobin”, “least connection first”, “round-trip”and “Xmitbyte” was carried out.

During last few years research has focusedon the so-called dynamic load balancing strate-

gies for web–oriented systems. Generally, thedynamic load balancing polices use some kindof feedback information from the cluster nodesto redirect the incoming request among thenodes. In [30] the so called “fewest server pro-cesses first” and “extended fewest server pro-cesses first” dynamic load balancing policieswere compared. The fewest server processes firstpolicy concept is (in our opinion) comparable toleast–connection policy. In both algorithms theleast loaded server gets the next incoming re-quest. The “extension” of the preliminary algo-rithm lies in the fact that the request can havepriorities. The paper presents high-level Petrinet approach to efficiency analysis of the poli-cies in different priority levels scenarios. A dy-namic web system load balancing policy pre-sented in [37] (AdaptLoad policy) adopts theload of the servers according to size of docu-ments requested. The policy builds a discretedata histogram encoding empirical size distri-bution of batches of K requests as they ar-


rive in the system. Each server “offers” fileswithin a certain range of size. The range de-pends of “popularity” of the files derived fromthe histogram. The paper presents simulationresults of the policy behaviour under histori-cal load conditions. Paper [6] at first discussessuch so called nonprediction–based load balanc-ing techiques as “first fit”, “stream–based map-ping” and “adaptive load sharing” correspond-ingly. The techniques are examined with respectto possible application in multimedia applica-tions. The prediction–based load balancing tech-niques as “least load first”, “prediction–basedleast load first”, “adaptive partition” and“prediction–based adaptive partition” are intro-duced and experimentally evaluated. In [22] asum of weighted factors such as CPU usage,memory usage, number of processors, numberof I/O operations, amount of free local storageand network I/O usage are taken into consider-ation to compute the load of a cluster node. Theload of the node may then be applied to a loadbalancing policy.

At the current state of the development ofthe HTCPNs–based tool, some selected loadbalancing HTCPNs templates were modelled.Three of the most widely applied polices suchas “random”, “round-robin” and “fewest serverprocesses first” were implemented. Addition-ally one experimental–“adaptive load sharing”policy was chosen for the implementation, be-cause as it was claimed in [6], this policy of-fers reasonable balance between the through-put and out–of–order departures of the exter-nal requests. In the following subsections theHTCPNs–based models of the mentioned loadbalancing policies will be presented. The fi-nal subsection will include some simulation re-sults of the HTCPNs–based load balancing al-gorithms. The model of the simplest– “random”load balancing policy was presented in subsec-tion 2.3.

3.1. Round-robin Load BalancingPolicy Model

Figure 8 presents HTCPNs–based model of thecomputer cluster similar to the cluster model

in Fig. 3. The cluster consists of 3 computersservicing requests incoming via PACKS1 portplace. The incoming Internet requests are redis-tributed among the cluster nodes according toround-robin load balancing policy. The modelof the policy works as follows. Each incomingpacket “passes” T2 transition and after the tran-sition firing the forth element of the tuple mod-elling the requests (see subsection 2.1) is modi-fied. The element includes a number of the serverwhere the packet will be serviced. Guard func-tions attached to T3, T4, T5 transitions “check”the fourth element of each packed model and“pass” the related requests. The presented loadbalancing policy model can be easily extendedto “weighted round-robin” policy by extendingthe numbers generated for the forth element ofthe packet tuple and by the corresponding mod-ifications of the guards.

3.2. Fewest Server Processes First LoadBalancing Policy Model

Figure 9 includes HTCPNs–based model of thecomputer cluster similar to the cluster modelin Fig. 3 and Fig. 8. The incoming Internetrequests are redistributed among the clusternodes according fewest serwer processes firstload balancing policy. The the model of the pol-icy works as follows. During the model execu-tion, the lengths of the queues in the queue-ing systems modelling servers are periodicallymonitored. The monitoring is possible due toappropriate construction of queueing systemsmodels (compare subsection 2.2). QL1, QL2,and QL3 places include the current values ofqueue’s lengths. The queue’s lengths are com-pared during BALANCE transition executionand FEWEST place acquires a number of theserwer which serves the fewest number of re-quests (the server with the shortest requestqueue). Guard functions associated to T3, T4,and T5 transitions “open” (for the incoming re-quests) only this branch of the cluster whichincludes the least loaded server. The frequencyof the queue’s lengths measurement can be ad-justed to derive the balance between additionalsystem load caused by the measurement and the


T2 PACKS2

PACKAGE

T3

[#4 pack =1]

T4

[#4 pack =2]

T5

[#4 pack =3]

PACKS3

PACKAGE

PACKS4

PACKAGE

PACKS5

PACKAGE

FIFO1

HS

FIFO2

HS

FIFO3

HS

PACKS8

PACKAGE

PACKS9

PACKAGE

PACKS10

PACKAGE

T8

T9

T10

PACKS13

PACKAGE

P Out

PACKS1

PACKAGE

P In

Load Balacer Server Cluster

CUR

INT1‘1

pack

(#1 pack, #2 pack, #3 pack, n,#5 pack,#6 pack)

pack

pack

pack

pack

pack

pack

pack

pack

pack

pack

pack pack

pack

pack

pack

pack

pack

pack

n if n<3 then n+1else 1

Figure 8. WWW cluster with round-robin load balancing policy

PACKS3

PACKAGE

PACKS4

PACKAGE

PACKS5

PACKAGE

PACKS8

PACKAGE

PACKS9

PACKAGE

PACKS10

PACKAGE

T8

T9

T10 PACKS13

PACKAGE

P Gen

PACKS2

PACKAGE

P Gen

QL1_

MEAN_TABLE1‘(0,0,0,0,0,0,0,0,0,0,1,0,1)

QL2_

MEAN_TABLE

1‘(0,0,0,0,0,0,0,0,0,0,1,0,2)

QL3_

MEAN_TABLE

1‘(0,0,0,0,0,0,0,0,0,0,1,0,3)

FIFO1

H

FIFO2

H

FIFO3

H

FEWESTINT

1‘1T3

[n=k]

T4[n=k]

T5

[n=k]

HS

BALANCE

Load Balancer Server Cluster

S1_ID INT1‘1

S2_ID INT1‘2

S3_ID INT1‘3

pack

pack

pack

packpack

pack

pack

pack

pack

pack

pack

pack

mean_ql_val1

mean_ql_val2

mean_ql_val3

k

find_fewest_proc_of3(mean_ql_val1,mean_ql_val2,mean_ql_val3)

n

n

n

kk

kk

kk

Figure 9. WWW cluster with fewest server processes first load balancing policy

quality of the balance process. It is possible todefine digital filters to “smooth out” the queuelength “signal”.

3.3. Adaptive Load Sharing – LoadBalancing Policy Model

Fig. 10 presents HTCPNs–based model of thecomputer cluster where the incoming Internetrequests are redistributed among the clusternodes according to adaptive load sharing load

balancing policy inspired by [6], [10]. The modelof the policy works as follows. During the sys-tem model execution lengths of the queues in thequeueing systems modelling servers are periodi-cally monitored. QL1, QL2, and QL3 places in-clude the current values of queue’s lengths. Dur-ing execution of the BALANCE transition theutilisation of each node of the cluster is calcu-lated. Depending on the utilisation values someranges of amounts of the Internet requests thateach server may serve are calculated. The cal-


PACKS3

PACKAGE

PACKS4

PACKAGE

PACKS5

PACKAGE

PACKS8

PACKAGE

PACKS9

PACKAGE

PACKS10

PACKAGE

T8

T9

T10 PACKS13

PACKAGE

P G

PACKS2

PACKAGE

P G

QL1_

QL_A_ID1‘(0,1)

QL2_

QL_A_ID

1‘(0,2)

QL3_

QL_A_ID

1‘(0,3)

FIFO1

H

FIFO2

H

FIFO3

H

B_TABLE

BAND_TABLE3

1‘((1,33),(34,66),(67,100))

T3

[b_guard31( b_tab3,pack)]

T4


T5


H

BALANCE

Load Balancer Server Cluster

pack

pack

pack

packpack

pack

pack

pack

pack

pack

pack

pack

qlen_a_id1

qlen_a_id2

qlen_a_id3

b_tab3

count_bands_of3(qlen_a_id1,qlen_a_id2, qlen_a_id3)

b_tab3

b_tab3

b_tab3

Figure 10. WWW cluster with adaptive load sharing load balancing policy

culated ranges are stored in B_TABLE place.Generally, servers having lower utilisation valueswill be given more chances to acquire the Inter-net requests in the future. Guard functions asso-ciated to T3, T4, and T5 transitions can be un-derstand as “valves” that adjust the amounts ofthe requests to be passed through to the serversaccording the range table stored in B_TABLEplace. The frequency of the queue’s lengths mea-surement can be adjusted to derive the balancebetween additional system load caused by themeasurement and the quality of the balance pro-cess. It is possible to define digital filters to“smooth out” the queue length “signal”.

3.4. Simulation Based on LoadBalancing Policies Evaluation

For the above mentioned models of load balanc-ing policies a set of simulation analysies wascarried out. In Figure 11 results of 2 differ-ent simulations are shown. Figure 11 (left) in-cludes queue lengths of 3 balanced servers whereload balancing policy followed round-robin algo-rithm. In the (right) simulation a performancedegradation of server 2 in 200000 time units was

modelled. It can be easily seen, that the load bal-ancer does not “notice” the performance degra-dation. The requests directed to second serverare serviced later than the others.

The queue lengths for clusters where fewestserver processes first and adaptive load sharingload balancing policies are coping with server 2performance degradation are shown in Fig. 12.Both polices (fewest server processes first –Fig. 12 (left), adaptive load sharing – Fig. 12(right)) “reconfigured” the loads for the clusternodes and managed to keep the average queuelengths for all cluster nodes at the same level.The simulation experiment proved that dynamicload balancing polices better cope with dynamicchanges during system execution. However, itmust be noticed that the dynamic load balanc-ing policies need some feedback information col-lected from the nodes of the cluster. To fulfillsuch requirement both modern load balancersand cluster nodes (e.g. WWW servers) soft-ware must be modified. Additionally the feed-back data collection can increase the load of thesystem.

Figure 13 shows more possibilities for designof dynamic load–balancing policies. The simula-


1 2 3 4 5 6 7 8 9

10

0 50000 100000 150000 200000 250000 300000 350000 400000

Que

ue L

engt

h


Queue 1,2,3 Lengths


0 5

10 15 20 25 30 35 40 45

0 50000 100000 150000 200000 250000 300000 350000 400000

Que

ue L

engt

h


Queue 1,2,3 Lengths


Figure 11. Queue lengths under round-robin load balancing policy (left) balanced (right) unbalancedafter server 2 performance reduction

0 2 4 6 8

10 12 14 16 18 20

0 200000 400000 600000 800000 1e+06 1.2e+06

Que

ue L

engt

h


Queue 1,2,3 Lengths


0 5

10 15 20 25 30 35 40 45

0 2e+06 4e+06 6e+06 8e+06 1e+07 1.2e+07

Que

ue L

engt

h


Queue 1,2,3 Lengths


Figure 12. Queue lengths under fewest server processes first (left) and adaptive load sharing (right)load balancing policy after server 2 performance reduction

tion results show that the application of somefeedback data to cluster state modification maycause system’s behaviour similar to control–loopsystems. In Figure 13 (left) the queue lengths os-cillations caused by an inadequate data collec-tion frequency may be noticed. The system inFig. 13 (right) seems to “suffer” from the highsensibility that may in consequence lead to theinstability.

4. Conclusions and Future Research

The first part of the paper introduces theHTCPNs–based software tool providing supportfor development and validation of web–serverclusters executable models. The main conceptof the tool lies in the definition of reusableHTCPNs structures (patterns) involving typicalcomponents of cluster–based server structures.The preliminary patterns are executable mod-

els of typical queueing systems. The queueingsystems templates may be arranged into servercluster subsystems by means of packet distribu-tion patterns. Finally, the subsystems patternsmay be naturally used for top level system mod-elling, where individual substitution transitions“hide” the main components of the system. Thefinal model is a hierarchical timed coloured Petrinet. Simulation and performance analysis arethe predominant methods that can be appliedfor the model validation. Queueing systems tem-plates was checked whether they meet theoret-ically derived performance functions. The anal-ysis of HTCPNs simulation reports enables topredict the load of the modelled system underthe certain arrival request stream; to detect thestability of the system; to test a new algorithmsfor Internet requests redirection and for theirservice within cluster structures.

The second part of the paper includes the re-view of recently published research results con-


0

20

40

60

80

100

120

0 200000 400000 600000 800000 1e+06 1.2e+06

Que

ue L

engt

h


Queue 1,2,3 Lengths


0

5

10

15

20

25

30

35

0 200000 400000 600000 800000 1e+06 1.2e+06

Que

ue L

engt

h


Queue 1,2,3 Lengths


Figure 13. Queue lengths under fewest server processes first load balancing policy:queue lengths oscillation (left), high system sensitivity (right)

cerning application load balancing policies inInternet systems. Subsequently, the HTCPNsbased models of some selected polices havebeen proposed. The most popular load balanc-ing policies models such as “random”, “roundrobin”, and “fewest server processes first” as wellas one experimental–“adaptive load sharing”have been applied and evaluated. The workedout HTCPNs structures become the integratedmodules of the HTCPNs based software toolpresented in the first part of the paper.

Currently, the software tool described in thepaper can be applied for a limited web–servercluster structures modelling and validation.Thereafter the main stream of author’s futureresearch will concentrate on developing nextweb–server node structures models. This mayresult in following advantages. First, an openlibrary of already proposed web–server clus-ter structures could be created and applied bythe future web–server developers. Second, somenew solutions for distributed web–server sys-tems may be proposed and validated.

References

[1] F. Bause. Queueing Petri Nets – a formalismfor the combined qualititative and quantitativeanalysis of systems. In PNPM’93, pages 14–23.IEEE, IEEE Press, 1993.

[2] H. Bryhni, E. Klovning, and O. Kure. Acomparison of load balancing techniques forscalable web servers. IEEE Network, Volume14(4):58–64, Jul./Aug. 2000.

[3] J. Cao, M. Andersson, C. Nyberg, and M. Khil.Web server performance modeling using an

M/G/1/K*PS queue. In CT 2003, 10th In-ternational Conference on Telecommunications,pages 1501–1506. IEEE, 2003.

[4] V. Cardellini, E. Casalicchio, and M. Cola-janni. The state of the art in locally distributedweb-server systems. ACM Computing Surveys,Volume 34(2):263–311, June 2002.

[5] V. Cardellini, M. Colajanni, and P. Yu. Dy-namic load balancing on web-server systems.IEEE Internet Computing, Volume 3(3):28–39,May/June 1999.

[6] J. Guo and L. Bhuyan. Load balancing in acluster-based web server for multimedia appli-cations. IEEE Transactions on Parallel andDistributed Systems, Volume 17(11):1321–1334,2006.

[7] K. Jensen. Coloured Petri Nets, Basic Con-cepts, Analysis Methods and Practical Use, vol-ume I-III. Springer, 1996.

[8] K. Jensen, L. Kristensen, and L. Wells.Coloured Petri Nets and CPN tools formodelling and validation of concurrent sys-tems. International Journal on SoftwareTools for Technology Transfer (STTT), Volume9(3-4):213–254, 2007.

[9] Y. Ji and I. S. Ko. A design of the simulatorfor web-based load balancing. Springer LNCS,Volume 4496/2007:884–891, July 2007.

[10] L. Kencl and J.-Y. L. Boudec. Adaptive loadsharing for network processors. In Twenty-FirstAnnual Joint Conference of the IEEE Com-puter and Communications Societies. Proceed-ings, pages 545–554. IEEE, 2002.

[11] D. Kim, S. Lee, S. Han, and A. Abraham. Im-proving web services performance using priorityallocation method. In Proc. Of InternationalConference on Next Generation Web ServicesPractices, pages 201–206. IEEE, 2005.


[12] S. Konunev. Performance modelling and eval-uation of distributed component–based sys-tems using Queuing Petri Nets. IEEETransactions on Software Engineering, Volume32(7):486–502, 2006.

[13] S. Kounev and A. Buchmann. SimQPN–atool and methodology for analyzing QueueingPetri Net models by means of simulation. Per-formance Evaluation, Volume 36(4–5):364–394,2006.

[14] M. Kristensen, S. Christensen, and K. Jensen.The practitioner’s guide to coloured Petri Nets.International Journal on Software Tools forTechnology Transfer (STTT), Volume 2:98–132,1998.

[15] T. T. Kwan, R. E. McGrath, and D. A. Reed.Ncsa’s world wide web server: Design and per-formance. Computer, Volume 28(11):68–74,Nov. 1995.

[16] B. Linstrom and L. Wells. Design/CPN Per-formance Tool Manual. CPN Group, Univ. ofAarhus, Denmark, 1999.

[17] Linux virtual server project. http://www.linuxvirtualserver.org/.

[18] X. Liu, L. Sha, Y. Diao, S. Froehlich, J. L.Hellerstein, and S. Parekh. Online responsetime optimization of Apache web server. InIWQoS 2003: 11th International Workshop,pages 461–478. Springer, 2003. LNCS.

[19] X. Liu, R. Zheng, J. Heo, Q. Wang, and L. Sha.Timing performance control in web server sys-tems utilizing server internal state information.In Proc. of the Joint Internat. Conf. on Auto-nomic and Autonomous Systems and Interna-tional Conference on Networking and Services,page 75. IEEE, 2005.

[20] loadbalancers.org. http://loadbalancer.org/.[21] Meta Software Corporation. Design/CPN Ref-

erence Manual for X-Windows, 1993.[22] G. Park, B. Gu, J. Heo, S. Yi, J. Han, J. Park,

H. Min, X. Piao, Y. Cho, C. W. Park, H. J.Chung, B. Lee, and S. Lee. Adaptive load bal-ancing mechanism for server cluster. SpringerLNCS, Volume 3983/2006:549–557, May 2006.

[23] T. Rak and S. Samolej. Distributed internetsystems modeling using tcpns. In Proc. of Inter-national Multiconference on Computer Scienceand Information Technology, pages 559–566.IEEE, 2008.

[24] S. Samolej and T. Rak. Timing properties of in-ternet systems modelling using Coloured PetriNets. In Systemy czasu rzeczywistego – Kierunkibadań i rozwoju, pages 91–100. WydawnictwaKomunikacji i Łączności, 2005. In Polish.

[25] S. Samolej and T. Szmuc. TCPN–based tool fortiming constraints modelling and validation. InSoftware Engineering: Evolution and EmergingTechnologies, Volume 130 Frontiers in ArtificialIntelligence and Applications, pages 194–205.IOS Press, 2005.

[26] S. Samolej and T. Szmuc. Time constraintsmodeling and verification using Timed ColoredPetri Nets. In Real–Time Programming 2004,pages 127–132. Elsevier, 2005.

[27] S. Samolej and T. Szmuc. Dedicated inter-net systems design using Timed Coloured PetriNets. In Systemy czasu rzeczywistego – Metodyi zastosowania, pages 87–96. Wydawnictwa Ko-munikacji i Łączności, 2007. In Polish.

[28] M. Satyanarayanan. Scalable, secure, andhighly available distributed file access. Com-puter, Volume 23(5):9–18, 20–21, May 1990.

[29] T. Schroeder, S. Goddard, and B. Ramamurthy.Scalable web server clustering technologies.IEEE Network, Volume 14(4):38–45, May/June2000.

[30] Z. Shan, C. Lin, D. Marinecu, and Y. Yang.Modelling and performance analysis ofQoS–aware load balancing of web–server clus-ters. Computer Networks, Volume 40:235–256,2002.

[31] B. A. Shirazi, A. R. Hurson, and K. M. Kavi.Scheduling and Load Balancing in Parallel andDistributed Systems. Wiley-IEEE Computer So-ciety Press, April 1995.

[32] F. Spies. Modeling of optimal load balancingstrategy using queueing theory. Microprocessingand Microprogramming, Volume 41:555–570,1996.

[33] Thomas-kern load balancers. http://www.thomas-krenn.com.

[34] B. Urgaonkar, G. Pacifici, P. Shenoy, M. Spre-itzer, and A. Tantawi. Analytic modeling ofmultitier Internet applications. ACM Transac-tions on the Web, Volume 1(2), 2007.

[35] L. Wells. Performance analysis using CPN tools.In Proc. of the 1st Inter. Conf. on Performance


Evaluation Methodolgies and Tools, 2006. Arti-cle No. 59.

[36] L. Wells, S. Christensen, L. Kristensen, andK. Mortensen. Simulation based performanceanalysis of web servers. In Proc. of the 9th Inter-nat. Workshop on Petri Nets and Perf. Models,page 59. IEEE, 2001.

[37] Q. Zhang, A. Riska, W. Sun, E. Smirni, andG. Ciardo. Workload-aware load balancingfor clustered web servers. IEEE Transactions

on Parallel and Distributed Systems, Volume16(3):219–233, March 2005.

[38] W. Zhang. Linux virtual server for scalable net-work services. In Ottava Linux Symposioum.Proceedings, 2000.

[39] Z. Zhang and W. Fan. Web server load balanc-ing: A queueing analysis. European Journal ofOperational Research, Volume 186(2):681–693,April 2008.

webâ€“server systems htcpns-based development tool application in

Documents