2010 Fourth IEEE International Conference on Self-Adaptive and Self-Organizing Systems Workshop
Comparing configurable parameters of swarm intelligence algorithms for dynamic load balancing
Vesna Sesum-Cavic
Eva Kühn
Institute of Computer Languages Vienna University of Technology Wien, Austria
[email protected]
Institute of Computer Languages Vienna University of Technology Wien, Austria
[email protected] There are many different approaches that cope with the LB problem. Research on LB algorithms comprises [18], [29]: different old-fashioned conventional approaches without using any kind of intelligence [7], [12], [21], [31], theoretical improvements of LB algorithms by using different mathematical tools and estimations without focus on implementation and benchmarks [3], and new intelligent algorithms like evolutionary approaches, and ant colony optimization [5], [13]. The intelligent algorithms from the last group show promising results. However, they still need improvement concerning experience in tuning of algorithms, and quality of solution they provide and scalability. Lemmens et al. [20] compared non-pheromone-based (bee intelligence) versus pheromone-based algorithms. Its conclusion is that the former are significantly more efficient in finding and collecting food. This insight formed the motivation for this paper to consider bee intelligence for the LB problem in order to improve the quality of the solution and scalability. In our previous work [18], we have proposed a LB framework termed SILBA (self initiative load balancing agents) that supports the exchange of pluggable and combinable algorithms (both unintelligent and intelligent1) as a test bed to ease the selection of the best algorithm for a certain problem scenario under certain conditions. SILBA is based on decentralized control and can be composed for usage not only within subnets but also between subnets. Self-organization is achieved by using a blackboard based style of collaboration to build up a shared view on the current state. The XVSM (extensible virtual shared memory) technology, which has already been successfully applied in several agents based projects [16], [17] serves as the coordination middleware for SILBA. The shared data structures maintain collaboration information like pheromones, overlay topology, and other LB relevant parameters to tune the algorithms. This indirect communication allows high autonomy of agents. The concurrently running agents either retrieve, or subscribe to this information being notified in near real-time about
Abstract—A main challenge on today’s distributed systems is to cope with huge amounts of load. An important research issue is to distribute load across enterprise boundaries in highly heterogeneous environments. However, intelligent and adaptive load balancing problem is a complex problem and requires both intelligent algorithms and approaches. In this paper, we present the first findings of a novel approach towards load balancing, based on bee intelligence. The approach defines a generic architecture called SILBA (self initiative load balancing agents) which allows the exchange of different algorithms through simple plugging techniques. Six algorithms were developed, both unintelligent and intelligent ones, compared and performance benchmarks on both a cluster of virtual nodes and the Amazon EC2 cloud demonstrate promising benefits of the bee based algorithm. Keywords: self-organization; autonomouos agents; load balancing
I.
swarm
intelligence;
INTRODUCTION
Load-Balancing (LB) is a significant problem in heterogeneous distributed systems. Nowadays, we face an extreme growth of computer systems and their complexities. The requirements on such systems are rapidly changing caused by new and varying market needs, as well as by technological evolutions. Developers of distributed systems therefore have to cope with an enormous increase in software complexity. Therefore, intelligent approaches that lead to autonomic self-organizing infrastructures will be needed, as self-organization is a proven approach to be useful in coping with complexity. Different examples prove the benefits of self-organization (for example, [1], [2], [10], [14], [19], [22], [28], [32], [34]). A dynamic load-balancing should improve the performance of the overall distributed system and achieve the highest level of productivity. LB can be described as finding the best possible workload (re)distribution and addresses ways to transfer excessive load from busy (overloaded) nodes to idle (underloaded) nodes. One must take in consideration the time needed for transferring the data from a busy node to an idle node and estimate the priority of transferring especially when the transfer itself requires more time to complete than the load assignment.
978-0-7695-4229-4/10 $26.00 © 2010 IEEE DOI 10.1109/SASOW.2010.12
1
42
By using the notion of “intelligent algorithms” it is often referred to the class of algorithms from artificial intelligence based on some kind of swarm intelligence or evolutionary computation.
changes, or modify it. Clients continuously put tasks to any node in the SILBA P2P infrastructure. Each LB algorithm consists of policies. The most important policies are the transfer policy (TP) and the location policy (LP). TP determines whether (and in which form) a resource participates in load distribution and in that sense, how the classification of resources is done. Two thresholds, TP1 and TP2, are parameters of TP, continuously adapted by each node. They allow for a classification of nodes according to their current load into three groups: under-loaded nodes (UL) with load ≤ TP1, OK nodes with a load between TP1 and TP2, over-loaded nodes (OL) with load ≥ TP2. The LP determines a suitable partner of a particular resource for LB [29],[31]. The LB algorithm regulates the coordinated interplay of these policies. In this paper, we present the second step, namely the implementation of different algorithms, fine tuning of parameters and comparison of unintelligent versus intelligent algorithms, by plugging them into the SILBA framework and benchmarking them. For the intelligent algorithms, we: 1) adapted and implemented two ant algorithms, and 2) adapted and for the first time implemented the concepts of bee intelligence to the LB problem. Although ant algorithms have been applied previously to the LB problem (e.g., [13]), we adapted and implemented them in order to do the comparison with non-pheromone based swarm intelligence (bee algorithm) in solving the LB problem [29]. This paper is organized in four sections. After an introduction, swarm based algorithms used in this paper are described in the second section. In the third section, benchmarks are explained (incl. the description of test examples and environments, results and their comparison, and the evaluation of results). The last section is the conclusion. II.
assignment in all-optical networks [23], training neural networks for pattern recognition [26], scheduling jobs for a production machine [27], and computer vision and image analysis [25]. Although some of these applications treat a kind of job scheduling, it differs a lot from our approach. Namely, they used a simplified version of a scheduling problem by including several limitation given in advance (e.g., a single machine supplies jobs, each job needs only one operation to be executed, etc.). The approach presented in this paper considers the LB problem more generally. Comparing the concepts of bee algorithms and ant algorithms, the following can be observed [29]: Bees [35] build up routes as overlays during their search of the network. If a bee finds the required information, it informs the “starting place” (its hive) of the search directly in a P2P way. So, knowledge distribution and communication between bees takes place in the hive. Ants [11] leave information (pheromones) at all nodes on the backward trip. A forward trip is comparable to the bees’ forward movement (navigation), but the backward trip is different – the ant does not directly contact the “starting place” (its nest) in a P2P way but must go the entire way back. A. Bee Algorithms In our previous work [29], we proposed the principles for usage of bee intelligence for LB. Software agents represent bees at the particular nodes. A node contains exactly one hive and one flower (with many nectar units). A bee takes nectar units out of flowers. If a flower is empty, it is not removed from the system. A task relates to one nectar unit. A hive has k receiver bees and l outgoing (i.e., forager plus follower) bees, k,l∈N. Initially, all outgoing bees are foragers. Foragers scout for an LP partner node of their node to pull or push nectar from/to it, and recruit followers. The main actors are foragers and followers, as receivers only process tasks at their node and have no influence on the algorithm. The goal is to find the best LP partner node by taking the best path which is defined to be the shortest one. A suitability function δ (see below) defines the best LP partner. A navigation strategy determines which node will be visited next and is realized by a state transitions rule:
SWARM BASED ALGORITHMS
Lemmens et al. [20] concluded that bee-inspired algorithms outperform ant algorithms in finding and collecting food. These facts motivate us to apply bee algorithms to LB. The biological bee behaviour is characterized by autonomy, distributed functioning, and selforganization [4]. A hive contains bees with different roles: foragers, followers, and receivers. The two main strategies in self-organization of bees are navigation and recruitment. The navigation means searching for nectar in an unknown landscape. A forager scouts for a flower with good nectar, returns to the hive, unloads nectar, and performs a recruitment strategy, meaning that it communicates the knowledge about the visited flowers (quality, distance and direction about nectar) to other bees [4]. A follower randomly chooses to follow a forager and visit the flower that has been “advertised” without searching itself. A forager can choose to become a follower in the next step of navigation, and vice versa. A receiver always stays in the hive and processes the nectar. Bee-inspired algorithms have been applied to several computer science problems like travelling salesman problem [35], job shop scheduling [6], routing and wavelength
Pij ( t ) =
[ ρ ij ( t )] α ⋅ [ 1
∑
j ∈ Ai ( t )
d ij α [ ρ ij ( t )] ⋅ [ 1
]β d ij
]β
(1)
adopted from [35], where ρij(t) is the arc fitness from node i to node j at time t and dij is the distance between i and j, α is a binary variable that turns on or off the arc fitness influence and β is the parameter that controls the significance of a heuristic distance. A recruitment strategy exchanges the obtained knowledge between bees about path (distance) and quality of the solution. From this, we can derive a fitness function
43
fi =
1 δ Hi
TABLE I.
(2)
search mode SM1
for a particular bee i, where Hi is the number of hops on the tour, and δ is the suitability function of the solution. The colony’s fitness function is the average of all single bees’ fitness functions f colony
1 = n
∑
n i =1
fi
SM2 SM3
(3)
where n is the number of bees. If bee i finds a highly suitable LP partner node (while using a “fast route” for travelling), then its fitness function, fi, will obtain a good value. After a trip, an outgoing bee determines how “good it was” by comparing its result with the average value, and based on that decides its next role (forager or follower) [24]. The success of a bee affects the credibility of its recruitment, expressed as a quotient between fi and fcolony. Each node can start LP: *) if the node is UL, its bee searches for a suitable task belonging to some OL node and carries the information about how complex task the node can accept; *) if the node is OL, its bee searches for an UL node that can accept one or more tasks from this OL node. It carries the information about the complexity of tasks this OL node offers and compares it with the available resource of the current UL node that it just visits. Therefore, the complexity of the task and the available resources at a node must be compared. For this purpose, we need the following definitions: task complexity c, host load hl and host speed hs [8]. Host speed represents the speed of the host and its value is relative in a heterogeneous environment. Host load represents the fraction of the machine that is not available to the application. Finally, task complexity is the time necessary for a machine with hs = 1 to complete a task when hl = 0. We calculate the argument x = (c/hs)/(1 – hl) of the suitability function δ and define it as δ = δ(x) (see Table II for possible forms). If x = 1, then the situation is ideal. The main intention is to find a good LP partner. For example, when an UL node with high resource capacities is taking work from an OL node, a partner node offering tasks with small complexity is not a good partner as other nodes could perform these small tasks as well; taking them would mean to waste available resources. All mentioned parameters are configurable. More details about the bee algorithm for LB can be found in [29]. In our implementation, we introduced one parameter, socalled search mode that is configurable and determines which nodes in the network (according to their load status) will trigger a load-balancing algorithm:
SM4 SM5 SM6
SEARCH MODES
description the algorithm is triggered from UL nodes, OK nodes (in a situation when it's likely that the node will become OL, but is not yet heavily loaded) and consequently OL nodes. the algorithm is triggered from UL nodes the algorithm is triggered from OK nodes (in a situation when it's likely that the node will become OL, but is not yet heavily loaded) and consequently OL nodes; the computation of x argument for δ(x) suitability is slightly changed2. the algorithm is triggered from OL nodes the algorithm is triggered from UL and OL nodes the algorithm is triggered from OK nodes (in a situation when it's likely that the node will become OL, but is not yet heavily loaded) and consequently OL nodes.
For the suitability function δ we implemented the following functions: TABLE II.
SF0 SF1 SF2 SF3
SUITABILITY FUNCTONS
one linear function: if (x = 1.0) δ(x) = n, else δ(x) = 5x (if the number of nodes ≤ n) an exponential function: δ(x) = 10x a polynomial function: δ(x) = 10x3 another linear function: if (x < 1.0) δ(x) = 4nx, else δ(x) = 5n (if the number of nodes ∈
[5n-4,5n])
The fitness function f is computed from the suitability function of the found node and the number of hops to this node and we used the following combinations: TABLE III.
FF0 FF1 FF2 FF3
2
FITNESS FUNCTIONS
f(x) = δ(x) / number_of_hops f(x) = δ(x)• (quality_of_links / number_of_hops) f(x) = δ(x) / sqrt(number_of_hops) similar to FF0, only the local node is excluded from the comparison and the rest of neighboring nodes are taken in consideration.
if a node is in OK state, the algorithm is triggered and searching for a suitable node among the neighbour nodes is started (afterwards, this information about the most suitable node is stored locally). As soon as the node gets OL, the tasks get re-routed to this target node. To achieve this “a priori” searching for a suitable node (when the information about a task is still unavailable, i.e., the task complexity c is yet unknown), we computed argument x only on the basis of host speed and host load parameters.
44
B. Ant Algorithms The basic requirements to be implemented, namely to find the best LP partner node by taking the best path, are the same like in the bee case. We define the best LP partner by using the maximum amount of pheromone left on the path. As ant algorithms are well-known and described in detail [9],[11], we do not provide here the description of ant algorithms in their original form, but rather present the way of adapting and remodelling these algorithms for the problem of interest. Re-modelling the algorithms (MINMAX [11] and AntNet [9]) for LP comprises the following changes. What does “Construct Solution” [11] mean in our case? The ant made a path and found the data on that path. We are not interested only in the best path, but also in the quality of the data found. Therefore, the DepositPheromone [11] procedure is changed as follows: If an ant on its trip 1) found exact data, it deposits pheromone; 2) found acceptable data with the accuracy/error rate < ε, (ε is a parameter given in advance related to the definition of δ), it deposits less amount of pheromone, 3) did not find data, it skips depositing pheromones on its trip (i.e., the values on arcs it traversed will be the same as the values on the rest of unvisited arcs in the network). A different amount of pheromones is deposited according to the quality of solution found. The general form of the suitability function δ is: δ = δ(currentSolution, exactSolution), that describes how good (acceptable) the found solution is, δ ∈ [0,1]. In case of changing the type of δ, its value can be scaled into the same segment [0,1]. DepositPheromone procedure is changed: 1) for MMAS algorithm: Δτ =1/MCbest where M=1/δ; 2) for AntNet algorithm: τ := r⋅(1-τ)⋅δ. III.
TABLE IV.
TEST PARAMETERS FOR BEE ALGORITHM
bee algorithm param. number of nodes number of tasks search modes
4,8,16,32,64 50,100,200,400,800 1,2,3,4,5,6
number of bees number of working agents3
4,8,16,32,64
suitability function
0,1,2,3
fitness function α β λ
0,1,2,3 0,1 from 8 to 12 with step 2 0.5, 0.7, 0.99
TABLE V.
1,2,4
TEST PARAMETERS FOR ANT (MINMAX) ALGORITHM
MINMAX parameters
BENCHMARKS
The tests are performed on a basis of several criterions: • For each intelligent algorithm find out the best combination of parameter settings. • Compare these optimally tuned swarm based algorithms with several well-known algorithms: Round Robin, Sender, and Adapted Genetic Algorithm (GA). The benchmarks demonstrate: 1) the agility of the SILBA pattern based framework by showing that algorithms can be easily exchanged, 2) the promising intelligent approach based on bee algorithms. As some algorithms are nondeterministic (swarm algorithms, GAs), the test-examples are performed 10 times and the average values are computed.
number of nodes number of tasks search modes number of ants number of working agents
4,8,16,32,64 50,100,200,400,800 1,2,3,4,5,6 4,8,16,32,64
suitability function
0,1,2,3
fitness function α β ρ
0,1,2,3 0.5, 1 from 2 to 5 with step 1 from 0.2 to 0.9 with step 0.2
TABLE VI.
1,2,4
TEST PARAMETERS FOR ANT NET ALGORITHM
AntNet parameters
A. Test Examples The test-examples are constructed according to the following tables:
number of nodes number of tasks search modes number of ants number of working agents
4,8,16,32,64 50,100,200,400,800 1,2,3,4,5,6 4,8,16,32,64 1,2,4
suitability function
0,1,2,3
fitness function α c2
0,1,2,3 0.2, 0.3, 0.45 0.15,0.25,0.3, 0.35
The setting and tuning of the parameters is obtained in the following way. The objective was not only to measure and compare the quality of the obtained results (expressed in 3
45
A detailed description can be found in [18].
one of the possible metrics – time in milliseconds), but also to investigate the scalability (specifically, a load scalability). Therefore, the main representatives for the resources (i.e., available nodes) and load (tasks, i.e., jobs to be done) are doubled. The number of used agents depends on the number of nodes and the setting follows the recommended values from [9], [11] and [29]. All kinds of search modes, suitability functions and fitness functions are used. The remaining parameters of each respective algorithm (cf. equations in section II and the procedures Construct Solution and Deposit Pheromone as described in [9],[11]) were set to the recommended values from [11] and [29]. The constant parameters are the initial threshold values: TP1 = 2 and TP2 = 4. However, these values are dynamically recalculated in the process [18]. All combinations were performed. For the tests, compilation tasks and an arbitrary topology were used in which full connection between all nodes was not required.
Sender/Receiver/Symmetric Algorithm. For the Sender algorithm, the OL node (Sender) initiates the routing. This can be achieved by configuring just one type of SILBA agent (“OUT allocation agent”) that is responsible for reading routing information from the space and pushing a work to another node in a network. Analogously, for Receiver algorithm, where the UL starts to look for available tasks, another type of agent (”IN allocation agent”) is responsible for reading routing information from the space and pulling work from another node in a network, must be scheduled at the corresponding local nodes. The Symmetric algorithm can be mapped by combining Sender and Receiver configurations. Adapted Genetic Algorithm (GA). We adapted the algorithm suggested in [36] to avoid the central coordinator. The routing agents of SILBA implement the algorithm. Several GAs are thus performed on different nodes concurrently. The description of the sliding window technique is remodulated. The size of window(s) is the same for all GAs and fixed to the number of nodes, where every node has the current (waiting) task as its candidate in that window. Every GA will obtain some combination according to the fitness function - they can be compared and the best one can be chosen as the final combination (at time t). The issue of who will be appointed to do the actions of “comparing” and “choosing” is also done by the routing agents. In addition, they communicate and exchange this information. Therefore, GA fires continuously, i.e., every OL node and UL node can trigger GA and the procedure is repeated until all requests are done. In our case, the sliding window is not directly dependent on a client which can put tasks somewhere in the network. A node has its load space for waiting (and new-coming) tasks which will be filled with requests from its node plus from all nodes of reachable networks each time when GA is triggered.
B. Test Environments Two different test environments were used: a cluster of 4 machines, and the Amazon EC2 Cloud. Each machine of the cluster had the following characteristics: 2*Quad AMD 2,0GHz with 16 GB RAM. We simulated a network with 16 (virtual) nodes. Each test run began with a “cold start" and all nodes were UL. On Amazon Cloud4, we used standard instances of 1.7 GB of memory, 1 EC2 Compute Unit (1 virtual core with 1 EC2 Compute Unit), 160 GB of local instance storage, and the 32-bit platform. C. Results and Overall Comparison The investigation of the best parameters settings for each algorithm, in both environments, led to the following results: • Bee algorithm: α = 1, β = 10, λ = 0.99, suitability function 3, fitness function 2; the best search mode was 4. • MINMAX algorithm: α = 1, β = 5, ρ=0.7, suitability function 3, fitness function 2; the best search mode was 6. • AntNet algorithm: α = 0.3, c2=0.3, suitability function 3, fitness function 2; the best search mode was 3. The load is generated by one client. Under these conditions (moderate system loads), the bee algorithm shows the best results when it is triggered from OL nodes, while ant algorithms show the best results when triggered from OK nodes (and consequently from OL nodes). The described swarm algorithms are compared with Round Robin, Sender, and Adapted GA that are implemented as follows: Random/Round Robin Algorithm. Some neighbours of the current node are statically stored in the routing space at an initialization phase. These neighbours are retrieved from the container, one of them is chosen randomly and the task is scheduled at the neighbour node. Similarly, Round Robin can be mapped. 4
The obtained results are given in Tables VII-X. The presented results correspond to the best search mode for the respective algorithm and they present time in ms:
TABLE VII. COMPARISON OF RESULTS OF BEE, MINMAX AND ANTNET ALGORITHMS (IN MILISECONDS, MS) OBTAINED ON THE CLUSTER
number of nodes
http://aws.amazon.com/ec2/
46
number bee of tasks algorithm
MINMAX algorithm
AntNet algorithm
4
50
316833
205000
323800
8
100
947322
542000
1037000
16
200
2889373
2720000
3685000
32
400
9823870
14142000
10334000
64
800
31927577
56217000
39534000
node) is chosen as well as the degree of self-organization of the used swarms. The average x value is 1, which means that the “best” node is always chosen. The absolute execution time is an important metric in many real use case scenarios. For example, in the Call Center use case [30], the absolute execution time is crucial as the proper functioning of distributing calls from clients to workers, accepting and handling them is directly proportional to the used time. Additionally, the scalability is analyzed. Here, we focus on the issue of load scalability. A very general definition of scalability is taken into account [15],[33]. Namely according to [15], a very general family of metrics can be based on the following definition:
TABLE VIII. COMPARISON OF RESULTS OF ADAPTED GA, SENDER AND ROUND ROBIN ALGORITHMS (IN MILISECONDS, MS) OBTAINED ON THE CLUSTER
number of nodes
number adapted GA of tasks
sender
round robin
4
50
592300
339880
347410
8
100
1896700
1391544
1142230
16
200
5311000
5366176
5711150
32
400
13278000
12646620
25423430
64
800
41832000
45586480
87865100
TABLE IX. COMPARISON OF RESULTS OF BEE, MINMAX AND ANTNET ALGORITHMS (IN MILISECONDS, MS) OBTAINED ON THE CLOUD
number of nodes
number of tasks
4
50
11782
15000
16000
8
100
28396
31000
33000
16
200
60556
61000
62000
32
400
122703
125000
128000
64
800
257385
273000
288000
bee algorithm
MINMAX algorithm
AntNet algorithm
ψ =
F (λ2 , QoS 2 , C 2 ) F (λ1 , QoS1 , C1 )
(4)
where F evaluates the performance, λ evaluates the rate of providing services to users, QoS is a set of parameters which evaluate the quality of the service seen by users and C reflects the cost. Further, [15] establishes the scaling strategy by means of a scaling factor k and the set of scaling variables which are functions of k. They express the strategy as a scaling path in a space in which they are the coordinates. In [15], it is possible to see how ψ(k) might behave in different situations (Fig.1):
TABLE X. COMPARISON OF RESULTS OF ADAPTED GA, SENDER AND ROUND ROBINALGORITHMS (IN MILISECONDS, MS) OBTAINED ON THE CLOUD
number of nodes
number of tasks
4
50
26000
16553
16748
8
100
45000
35996
32408
16
200
63000
63248
64817
32
400
135000
156638
195319
positive scalability
64
800
298000
413426
807118
perfect scalability
adapted GA
sender
round robin
Scalability ψ(k) superscalable
1
D. Evaluation Using the absolute execution time as metric for the benchmarks, bee algorithms showed the best results compared with the other algorithms. On the cluster, the bee algorithm on 64 nodes performs 43% faster than MinMax, 19% faster than AntNet, 24% faster than Adapted GA, and 29% faster than Round Robin. In the Amazon EC2 Cloud, the bee algorithm on 64 nodes is 5% faster than MinMax 10% faster than AntNet, 13% faster than Adapted GA, 37% faster than Sender, and 68% faster than Round Robin. Also, MINMAX ant algorithm performed good on the cluster. A good behaviour and results of bee algorithm are connected with an efficient matching (i.e., good suitability through the used function). Moreover, the values of the suitability function (i.e., the value of argument x) help to discern the usefulness of the intelligent algorithms and emphasize the correctness of properly chosen partner nodes, i.e., the methodology to determine the best partner node. This function reflects how good solution (i.e., the partner
threshold case
unscalable
Scale factor k
Figure 1. Scaling behavior [15]
We specialized it to a simplified version of interest to our problem in terms of load, resources and performance measure. This restricted aspect of scalability can be quantitatively described on the basis of computational resources available (R), load of the system (L) and some performance measure (P). Then scalability can be quantified by means of a “scalability ratio” rscal for a given constant k
rscal =
47
P ( L, R ) P(kL, kR)
(5)
extensions of the SILBA framework that allow load balancing on several levels: between different subnets, simultaneously with load balancing between nodes within these subnets. Each level can apply a different type of algorithm and load balancing in the whole network is realized through the combination of all these algorithms. Future work will also include the benchmarking of large instances, and will pay attention to security issues. Also, future work will consider another direction, i.e., except suggested enlarging the parameter space, a direction to shrinking parameter space can also be beneficial with more samples and more determinism in order to understand better the nature of swarm intelligent algorithms.
Usually, performance P is the function of load L and resources R. A certain aspect of scalability is described by the answer to the question of how P is affected when more resources (larger R) have to compensate for more load (larger L). A constant remaining value of P when simultaneously increasing L and R by the same factor leads to the “ideal” scalability ratio of 1. In our test examples, this interpretation of load scalability is applied. We analyzed the increasing of load with the increasing of the resources. By comparing our preliminary result in Table 2a and Table 2b with Fig. 3, it is easy to see that swarm algorithms (and especially bee algorithms) scale well [15]. For example in the cluster environment, load and resources are increased twice for consecutive test runs, i.e., they are increased by 2n compared with the starting test run (4 nodes, 50 tasks). The values of rscal are 2.9, 3.0, 3.4, 3.2 (rounded to one decimal) for consecutive bee test runs, i.e., 2.9, 9.1, 31.0, 100.8 compared with the starting test run (4 nodes, 50 tasks). These values converge to positive scalability. Such behaviour is even better in a more real environment, i.e., on the Cloud. Almost the similar situation occurs with AntNet algorithm. IV.
REFERENCES [1]
[2]
CONCLUSION
Load balancing is an important IT problem that seeks for advanced solutions. A use case for applying the results is the Call Center [30]. In this paper, the advantages of using bee swarm intelligence in the context of load balancing are presented. Additionally, two further intelligent algorithms are adapted based on MINMAX and AntNet ant algorithms. For these three algorithms, the best combination of feasible parameters was identified. For the comparison and evaluation a generic load balancing framework that allows the plugging and thus easy exchange of algorithms was used. The three intelligent algorithms were compared with three well-known algorithms, Round Robin, Sender, and Adapted Genetic Algorithm. The benchmarks were carried out in two independent hardware environments, a local cluster at the university, and the Amazon EC2 Cloud. The load was generated by one single client (moderate system load) and as performance parameter the absolute execution time was used. Under these conditions, the obtained results show that the bee algorithm outperforms all other test candidates. Self-adaptive system modifies its own behaviour in response to changes in its dynamic environment. In our system, the suitability function and fitness function are responsible for self-adaptation. Software agents use knowledge gained from previous attempts to make an adaptation in a path construction. Future work will concern different metrics used for the evaluation of results (e.g., communication delay, utilization, fairness across multi-user workloads, robustness in the face of node failure, adaptability in the face of different workloads), more clients responsible for supplying the load into the network (high system loads), different frequencies in supplying the load, different network topologies, and
[3]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11] [12]
[13]
48
O. Babaoglu, G.Canright, A.Deutsch, G. Di Caro, F.Ducatelle, L. Gambardella, N.Ganguly, M. Jelasity, R. Montemanni, A. Montresor and T. Urnes, “Design Patterns from Biology for Distributed Computing,” ACM Transactions on Autonomous and Adaptive Systems, 1(1), pp. 26–66, 2006. O. Babaoglu, T. Binci, M. Jelasity, and A. Montresor, “Firefly-inspired Heartbeat Synchronization in Overlay Networks,” 1st Int. Conf. on Self-Adaptive and SelfOrganizing Systems (SASO 2007), Washington, DC, 2007. A.G. Bronevich and W. Meyer, “Load-balancing algorithms based on gradient methods and their analysis through algebraic graph theory,” Parallel and Distributed Computing, 68, pp. 209-220, 2008. S. Camazine and J. Sneyd, “A model of collective nectar source selection by honey bees: Self-organization through simple rules,” Journal of Theoretical Biology, 149(4), pp. 547-571, 1991. J. C. Chen, G. X. Liao, J. S. Hsie and C. H. Liao, “A study of a contribution made by evolutionary learning on dynamic load-balancing problems in distributed computing systems,” Expert Systems with Applications, 34, pp. 357-365, 2008. C. S. Chong, A. I. Sivakumar, M. Y.Low and K. L Gay, “A bee colony optimization algorithm to job shop scheduling,” 38th Conference on Winter Simulation, California, pp. 19541961, 2006. A. Cortes, A. Ripoll, F. Cedo, M.A. Senar and E. Luque, “An asynchronous and iterative LB algorithm for discrete load model,” Parallel and Distributed Computing, 62, pp. 17291746, 2002. D.P. Da Silva, W. Cirne, F.V. Brasileiro and C. Grande, “Trading Cycles for Information: Using Replication to Schedule Bag-of-Tasks,” Applications on Computational Grids, Euro-Par 2003, pp. 169-180, 2003. G. Di Caro and M. Dorigo, “AntNet: Distributed Stigmergetic Control for Communications Networks,” Journal of Artificial Intelligence Research, 9, 1998. G. Di Marzo Serugendo, M. Gleizes and A. Karageorgos, “Self-Organisation and Emergence in MAS: An Overview,” Informatica, 30, 2006. M. Dorigo and T. Stuetzle, Ant Colony Optimization, MIT Press, 2005. D. L. Eager, E. D. Lazowska and J. Zahorjan, “Adaptive Load Sharing in homogeneous distributed system,” IEEE Transaction on Software Engineering, 12(5), pp. 662–675, 1986. C. K. Ho and H. T. Ewe, “Ant Colony Optimization approaches for the dynamic Load-Balanced Clustering
[14]
[15]
[16]
[17]
[18]
[19]
[20]
[21]
[22]
[23]
[24]
[25]
[26]
[27]
[28]
Problem in Ad-Hoc Networks,” Swarm Intelligence Symp., Hawaii, 2007. M. Jelasity, O.Babaoglu and R. Laddaga, “Guest Editors' Introduction: Self-Management through Self-Organization”, IEEE Intelligent Systems, 21(2), pp.8-9, 2006. P. Jogalekar and C. M. Woodside, “Evaluating the Scalability of Distributed Systems,” IEEE Transactions on Parallel Distributed Systems, 11(6), pp. 589-603, 2000. E. Kühn, R. Mordinyi, L. Keszthelyi and C. Schreiber, “Introducing the concept of customizable structured spaces for agent coordination in the production automation domain”, 8th Int. Conf. on Autonomous Agents and Multiagent Systems, AAMAS, Budapest, Hungary, 2009. E. Kühn, R. Mordinyi, M. Lang and A. Selimovic, “Towards zero-delay recovery of agents in production automation systems,” IEEE/WIC/ACM Int. Conf. on Intelligent Agent Technology (IAT), Italy, 2009. E. Kühn and V. Sesum-Cavic, “A Space-Based Generic Pattern for Self-Initiative Load Balancing Agents,” 10th Annual Int. Workshop Engineering Societies in the Agents World (ESAW 2009), LNAI Springer Verlag, Utrecht, Netherlands, 2009. K. Lehmann and M. Kaufmann, “Evolutionary Algorithms for the Self-Organized Evolution of Networks,” Genetic and Evolutionary Computation Conf. (GECCO 2005), USA, 2005. N. Lemmens, S.de Jong, K. Tuyls and A. Nowe, “Bee Behaviour in Multi-agent Systems,” Adaptive Agents and MAS III, LNAI 4865, pp.145-156, 2008. F. H. Lin and R.M. Cellars, “The gradient of modelling Loadbalancing Method,” IEEE Transactions on Software Engineering, 1987. M. Mamei, R. Menezes, R. Tolksdorf and F. Zambonelli, “Case Studies for Self-Organization in Computer Science,” Journal of Systems Architecture, 52(8), pp. 443-460, 2006. G. Markovic, D. Teodorovic and V. Acimovic-Raspopovic, “Routing and wavelength assignment in all-optical networks based on the bee colony optimization,” AI Commun. 20(4), pp. 273-285, 2007. S. Nakrani and C. Tovey, “On honey bees and dynamic server allocation in the Internet hosting centers,” Adaptive Behaviour, 12(3-4), pp. 223-240, 2004. G. Olague and C. Puente, “The Honeybee Search Algorithm for Three-Dimensional Reconstruction,” 8th European Workshop on Evolutionary Computation in Image Analysis and Signal Processing, LNCS 3907, pp. 427–437, 2006. D.T. Pham, A.J. Soroka, A. Ghanbarzadeh, E. Koc, S. Otri and M. Packianather, “Optimising neural networks for identification of wood defects using the Bees Algorithm,” IEEE International Conference on Industrial Informatics, Singapore, 2006. D.T. Pham, E. Koç E, J.Y. Lee and J. Phrueksanant, “Using the Bees Algorithm to schedule jobs for a machine,” 8th International Conference on Laser Metrology, pp. 430–439, Cardiff, UK, 2007. N. Salazar, J. Rodriguez-Aguilar and J. Arcos, “An InfectionBased Mechanism for Self-Adaptation in Multi-Agent Complex Networks,” 2nd IEEE Int. Conf. on Self-Adaptive
[29]
[30]
[31]
[32]
[33]
[34]
[35]
[36]
and Self-Organizing Systems (SASO 2008), Washington, 2008. V. Sesum-Cavic and E. Kühn, “Instantiation of a Generic Model for Load Balancing with Intelligent Algorithms,” 3rd Int. Workshop on Self-Organizing Systems (IWSOS 2008), LNCS, Vienna, Austria, 2008. V. Sesum-Cavic, E. Kühn, “Applying swarm intelligence algorithms for dynamic load balancing to a Cloud Based Call Center,” to appear, 4th IEEE International Conference on SelfAdaptive and Self-Organizing Systems, IEEE/SASO 2010, Budapest, Hungary, 2010. N.G. Shivaratri and P. Krueger, “Adaptive Location Policies for Global Scheduling,” IEEE Transactions on Software Engineering, 20 (6), pp. 432 - 444, 1994. H. Van Dyke Parunak and S. Brueckner, “Entropy and SelfOrganization in Multi-Agent Systems,” 5th Int. Conf. on Autonomous Agents, Montreal, Canada, 2001. M. Van Steen, S. Van der Zijden and H.J. Sips, “Software Engineering for Scalable Distributed Applications,” 22nd Computer Software and Applications Conf., Vienna, 1998. M. Viroli, and M. Casadei, “Biochemical Tuple Spaces for Self-Organising Coordination,” 11th Int. Conf. on Coordination Models and Languages (COORDINATION 2009), Lisbon, Portugal, 2009. L.P. Wong, M.Y.H. Low and C.S. Chong, “A Bee Colony Optimization for Traveling Salesman Problem,” 2nd Asia Int. Conf. on Modeling and Simulation, pp. 818-823, Malaysia, 2008. A.Y. Zomaya and Y-H. The, “Observations on using genetic algorithms for dynamic load-balancing,” IEEE Transactions on Parallel and Distributed Systems, 12, 2001.
APPENDIX Legend of Terms: FF fitness function GA genetic algorithm LB load balancing LP location policy MINMAX min-max ant system algorithm OK ok-loaded OL overloaded SF suitability function SILBA self initiative load balancing agents SM search mode TP transfer policy UL under-loaded XVSM extensible virtual shared memory
49
