A distributed scheduling framework based on selfish autonomous agents for federated cloud environments

Future Generation Computer Systems 29 (2013) 1461–1472

Contents lists available at SciVerse ScienceDirect

Future Generation Computer Systems journal homepage: www.elsevier.com/locate/fgcs

A distributed scheduling framework based on selfish autonomous agents for federated cloud environments Francesco Palmieri, Luigi Buonanno, Salvatore Venticinque ∗ , Rocco Aversa, Beniamino Di Martino Department of Information Engineering, Second University of Naples, Via Roma 29, I-81031 Aversa (CE), Italy

article

info

Article history: Received 28 January 2012 Received in revised form 20 December 2012 Accepted 30 January 2013 Available online 19 February 2013 Keywords: Nash equilibrium Selfish solution search Distributed job scheduling Autonomous agent systems Federated clouds

abstract Today, large-scale distributed Cloud computing infrastructures are often characterized by the fact that each participating organization, like a company in the free economy scenario, when making its resources available, will strive for reducing its own cost and for optimizing its own benefit, regardless of the consequences on the global Cloud’s welfare, in terms of effectiveness and performance losses. The selfish behavior of all these entities (end-users, Cloud providers, underlying enterprises/data centers), competing strategically for resources (distributed storage, processing power, bandwidth), motivates the use of game theory and autonomous agents for effective Multi-User Task Scheduling. Accordingly, we present a novel uncoordinated fully distributed scheduling scheme for federated cloud organizations, based on independent, competing, and self-interested job/task execution agents, driven by optimum social welfare criteria towards a Nash equilibrium solution. The agents’ behavior is also conditioned by marginal costs, to force some kind of implicit coordination between the (often conflicting) objectives of the various entities involved in the cloud. Due to its inherent parallel nature, such schema can provide a significantly better scalability in presence of a large number of tasks and resources involved into the scheduling system. © 2013 Elsevier B.V. All rights reserved.

1. Introduction The emerging Cloud computing paradigm represents an important architectural shift from the traditional distributed computing approaches. From the end-users’ view, Cloud computing moves the application software from their own devices to the Cloud side, which makes users able to plug-in anytime from anywhere and utilize large-scale storage and computing resources by dynamically expanding and contracting their demands with the natural flow of the involved business life-cycle. Specifically, end-users rent resources from Cloud infrastructure providers, according to a pay-per-use pricing model, to deploy specific service instances in the form of virtual machine (VM) images or runtime applications. On the other hand, the providers are responsible for dispatching the execution of these instances on their physical resources. In doing this, they have to focus on how to automatically and dynamically distribute and schedule the involved tasks according to the current workloads experienced on their infrastructures. This elastic management aspect of Cloud computing allows applications to scale and grow without needing traditional

∗

Corresponding author. Tel.: +39 0815010273. E-mail addresses: [email protected], [email protected] (F. Palmieri), [email protected] (L. Buonanno), [email protected], [email protected] (S. Venticinque), [email protected] (R. Aversa), [email protected] (B. Di Martino). 0167-739X/$ – see front matter © 2013 Elsevier B.V. All rights reserved. doi:10.1016/j.future.2013.01.012

‘‘fork-lift’’ upgrades. However, there is a fundamental characteristic distinguishing modern Cloud computing infrastructures from traditional distributed systems. At the most basic level, the emergence of Clouds can be viewed as the computing equivalent of the electricity market evolution that took place a century ago, when farms and businesses shut down their own generators and bought power from efficient industrial utilities. Also the service model is very similar to that for basic utilities, such as gas, electricity and water, and thus primarily driven by economics. This often implies conflicting objectives between the involved parties, hindering the pricing model’s effective application and hence affecting the overall Cloud success. Furthermore, the largest Clouds are generally a conglomerate of interconnected, redundant data centers located throughout the world and specifically realized to provide certain services. These data centers are typically governed by other socioeconomic entities whose main interest is not the optimization of the Cloud’s performance in its entirety, but rather the maximization of their own benefit. Moreover, there may not be a central authority that controls that every participating user or resource provider behaves in a benevolent, globally coordinated manner, by scheduling the involved tasks on the available resources in such a way that maximizes the overall Cloud’s objective function (e.g., the perceived or effective performance). Thus, in absence of any kind of coordination, the above ‘‘selfish’’ behavior results in inefficient scheduling decisions, implying underutilized resources and suboptimal performance. Hence, the understanding of the mechanisms

1462

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

behind the selfish behavior of the involved entities in such noncooperative systems is of primary importance in resolving largescale distributed scheduling problems where each organization may be characterized by completely different and even conflicting performance objectives and optimization criteria. A natural framework in which to study such multi-objective optimization problems is the classic game theory. In such a context, the above optimization problem, because of the implicit need of a coordination mechanism, can be modeled as a non-cooperative strategic game of independent entities (players) modeled by using autonomous agents. These entities do not operate according to a common strategy, but act in a purely selfish manner, aiming at maximizing their own objective functions. The game theory predicts that selfish behavior in such a system can lead to a Nash equilibrium (NE), which is a particular point of stability in the system where no player can achieve further advantages by unilaterally changing its strategy [1]. This approach can be used to optimize a global objective function taking into account the selfish behavior of all the participating entities. That is, in such situations where it is difficult or even impossible to impose optimal resource scheduling strategies on a geographically distributed Cloud infrastructure, we exploit some less evident interaction dynamics among all the player’s choices, so that selfish behavior leads to a socially desirable outcome. Players, according to a decentralized scheduling scheme, selfishly choose their private strategies, apparently without considering the other players’ strategies. To force some kind of coordination among the selfish strategies, specific additional tolls, the so-called marginal costs – associated to the conflicts with the other strategies insisting on the same resources – are bounded to each resource. These costs can implicitly condition the selection process and do not directly affect the agents’ selfish behavior, so that the global game may progressively converge to an equilibrium state. The resulting distributed scheduling scheme for federated Cloud infrastructures is based on a slotted time model to provide advance reservation of resources in a fully distributed scenario. It is substantially different from the traditional ones, since it integrates the game theory, needed to drive the complex interactions among the users and resource providers towards a socially optimal method to deal with their own demand and objectives, together with multi-agent systems, commonly recognized as the best available solution to model highly dynamic and complex systems, because of their reactivity and competition capabilities. 2. Related work Job Scheduling on distributed infrastructures has taken considerable efforts from many researchers. The associated problem, widely simplified, is closely related to a commonly known combinatorial optimization problem, known as ‘‘bin packing’’, that is NPhard in its general form [2]. Here, the items to be packed are viewed as the jobs to be run and the bins as the machines deployed on the distributed infrastructure, with their capacity represented by the available computing power. To cope with such an intractable complexity, several meta-heuristic approaches have been proposed, exploring the solution space and trying to determine near-optimal solutions. Most of these approaches are based on a single heuristic method such as Genetic Algorithms [3,4], Simulated Annealing [5] or Tabu Search [6]. Several works presented game theoretic models to solve job scheduling problems by using the solution concept of Nash equilibrium [7]. In particular, scheduling based on selfish agents was first analyzed in the seminal work of Nisan and Ronen [8], who conceived the n-approximation MinWork scheme. Carroll and Grosu [9] developed a distributed version of the above scheme protecting the privacy of the bids. The MinWork scheme was also

successively improved by Archer and Tardos [10] by developing a truthful 3-approximation randomized mechanism. These results have been further improved by Auletta and Andelman with a deterministic truthful 4+ approximation mechanism for respectively a fixed [11] and an arbitrary [12] number of machines. Even-Dar [13] considered the convergence time to Nash equilibria for several selfish scheduling problem variants and in particular, examined the Makespan policy and bounded the number of steps needed to reach a pure Nash equilibrium. According to a more economicbased approach, Bredin [14] developed a decentralized negotiation strategy in auctioning of divisible resources and demonstrated that the auction exhibits a unique Nash equilibrium. Similarly, An [15] presented a market-based proportional resource allocation mechanism for multi-agent system funded on game theoretical analysis. Finally, game-theoretic approaches have also been recently applied explicitly to resource allocation schemes in grid and Cloud architectures. In detail, Kwok [16] pioneered the development of a hierarchical game theoretic model of a computational grid and analytically studied the optimal strategies for the general selfish resource allocation. In the same scenario, Khan [17] performed a comparison among game theoretic resource allocation schemes based on different design rationales: noncooperative, semi-cooperative and cooperative. Also Li [18], developed a utilitydriven solution for optimal resource allocation in grids. Gametheoretic concepts have been applied to Cloud computing in [19], introducing the concept of collocation games. The presented approach differs from the above ones in being based on a fully distributed competition gaming schema, accounting for the inherently conflicting interests of the clients and the service provider entities operating within a Cloud, that does not rely on any form of centralized control and delegates the schedule of clients’ tasks to a community of selfish agents, driven by implicit taxes (marginal costs) and social utility criteria towards a Nash equilibrium solution. It also bases its resource allocation strategy on advance reservation within the context of a slotted time model in order to correctly support specific Service Level Agreements (SLA) associated to users’ demands (according to the models presented in [20,21]), and manage the flexible co-allocation of resources and service components within distributed cloud infrastructures crossing the boundaries of several resource/cloud providers, as shown in [22]. In doing this it is able to effectively aggregate resources from multiple places in order to provide Qualityof-Service in a distributed multi-site computing environment [23]. Additionally, it makes the task execution more predictable [24] by reserving specific capabilities over well-defined time intervals on the available cloud resources and increases admission probability for user demands in presence of sufficiently early reservations and reliable resource scheduling plans. On the other hand, an excessively aggressive reservation policy may result in a low resource utilization and lead to a high rejection rate [25]. Most of the available commercial cloud solutions such as Amazon EC2 , Flexiscale or ElasticHost base their resource allocation strategies on immediate reservation. However, runtime requests for modern Cloud infrastructures that are subject to nontrivial policies and time-bound resource reservations to meet peak capacity requirements, need to rely on advance reservation in order to ensure the correct execution, at the right times, of the service workload within or across the involved cloud providers. At the state-of-the-art the most significant experience concerning the support of advance reservation in cloud infrastructures is the Haizea [26,27] lease manager that can act as a scheduling backend for OpenNebula to implement reservation and resource preemption mechanisms. The OpenNebula default scheduler provides a rank scheduling policy that places VMs on physical resources according to a ranking algorithm that is highly configurable by the administrator, and relies on real-time data from both the running VMs and available physical resources [28]. Combining it with

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

Haizea allows cloud providers to lease their resources by using complex and flexible lease terms, such as the advance reservation of computing and storage capacity, instead of only allowing users to make request that must be handled immediately. 3. Model and objectives A Cloud computing system spanning across multiple geographical locations (i.e. fully distributed) can be modeled as a finite set of physical resources (processing elements/cores, storage space) fully interconnected in the sense that a connection or route, with specific bandwidth, exists between any individual resource and the rest of the Cloud. These resources may be located in different data centers scattered throughout the world, managed according to a federated cooperation model. We assume that, the available resources are not homogeneous in terms of their computing capability, storage capacity and connectivity to the Cloud, and hence each instance of a specific resource is fully independent from the other ones and only characterized by its own features. We are interested in modeling a scalable distributed scheduling mechanism on such a complex cloud system, that is the problem of allocating a limited quantity of independently managed resources to a specific number of independent user tasks (VMs or applications/jobs to be run etc.) in a limited operation time, without the need of any centralized coordination and control facility. From now on, the terms task and job will be used interchangeably. In order to support SLAs within the cloud workload, by managing job execution and virtual machine placement requests characterized by specific computing power, storage space or network connectivity demands as well as an earliest start time, an estimated execution time and a completion deadline, the available resources will be allocated to tasks according to a time-slotted advance reservation paradigm, where the computing/storage requirements and execution time limits/ranges of the demands are known in advance. Accordingly, the dynamically arriving tasks are temporarily queued until the end of the current time slot, to be considered for scheduling at the start of a new one. In such model, the time is slotted with a slot size equal to 1t, where this length depends on the minimum duration of an advance reservation. Each advance reservation request can only start at the beginning of a time slot and is described by a 4-tuple, r = (p, q, s, e) where p and q are respectively its computing and storage requirements, and s and e are the starting and ending time of its scheduling window. The scheduling window defines the acceptable execution time range of the request, so that if it cannot be successfully scheduled within such time period, the request will be withdrawn. At each time slot, the cloud organization has to cope with an active list of execution requests R = {r1 , . . . , rn } to be served. For each individual request r ∈ R that is still inside its validity time range, the proper runtime resources should be allocated on the cloud for its execution. If the required resources are not currently available, the involved runtime request will be deferred to the next time-slot, and this process will be iterated until either the request is satisfied or its time window expires. Once some resource have been allocated, they are extracted from the cloud’s available resource pool, and they will remain unavailable until the associated request is not completed. Consequently, at the start of each time slot the cloud provider has to check for the completion of all the currently executing tasks to return back their associated resources to the available resource pool. Clearly, according to this slotted model, a new scheduling problem has to be solved on each time slot, to handle the execution of the new tasks (arrived after the start of the previous time slot) as long as of those valid ones that have not been successfully scheduled within the previous time slot. A distributed approach is necessary to cope with the intractable computational nature of the above scheduling problem to ensure,

1463

in presence of a very large number of tasks, an acceptable degree of scalability through the decomposition of the original problem into smaller and hence simpler ones, that can be run in parallel, and whose results can be combined into a final comprehensive scheduling plan. In fully distributed settings, the operating scenario is significantly different from the traditional centralized one, because machines and tasks to be ran on them may be bound to different entities, interested only in their own objectives, and not in the global ones. Therefore it is useful to analyze the associated scheduling problem from a game theoretic perspective [29,30]. We can distinguish three different layers within the system, which consist of the main Cloud provider, the individual data center infrastructure owners, and the end-users. Ideally, any scheduling strategy operating in this scenario should satisfy the objectives of all these parties. We model such scheduling strategy according to the classic game theory, by focusing on multiple job requests from a number of users and a set of runtime services offered by several computing and storage resources providers operating within the Cloud. In detail, we consider, for each time slot t a scheduling game characterized by:

• a set of machines M = {m1 , m2 , . . . , m|M | } where each mi can have different speeds si and current workload capacities wi , available storage capacities di and are connected to the Cloud through a connection with bandwidth bi , with i ∈ {1, 2, . . . , |M |}; • a set of users U = {u1 , u2 , . . . , u|U | } competing for service on the above machines where to each user uj with j ∈ {1, 2, . . . , |U |} is associated a set of n jobs Jj = {Jj,1 , Jj,2 , . . . , Jj,n }, where each job Jj,k ∈ Jj with k ∈ {1, 2, . . . , n} has a processing time demand pj,k and a storage demand qj,k so that, at any specific time slot, for each machine mi ∈ M:



xj,k (i) · pj,k ≤ wi

j∈U k∈Jj



xj,k (i) · qj,k ≤ di

and (1)

j∈U k∈Jj

where xj,k (i) is a binary variable that is set only when the job Jj,k is assigned to run on the machine mi . Hence it defines a global mapping among the jobs to be executed on the Cloud and the available machines. Splitting jobs among several machines is not allowed, so that, on each time slot one job can be assigned to one machine only. We also assume that, a job is released immediately after it is processed on a machine. This means that an implicit sequencing policy is needed for each machine to determine the processing order of the set of jobs assigned to it. In the above model, the processing demands pj,k and the workload capacities wi can be expressed in ‘‘computing power units’’, whereas the storage demands qj,k and the workload capacities di can be expressed in ‘‘storage units’’. Analogously, the machine speeds si , can be expressed in computing power units/s and the connection bandwidth in storage units/s. The time-slotted advance reservation logic is flexible enough to also model the elastic behavior of modern cloud infrastructures where already running VMs or applications can migrate between several machines during their execution lifetime. This can be potentially achieved by relaxing the task unsplittability constraint among different time slots, so that, at the end of each time slot, the active tasks provisionally release the machines/resources they are currently running on, and come back to the execution demand queue for the next time slot, where they can be rescheduled on different resources. This obviously implies updating their computing demands pj,k by subtracting them the quantity si · 1t to take

1464

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

into account the time they have already run on the machine i. Clearly, if an already running task cannot be rescheduled in the next time slot, the provisional resource release must be rolled back and the task left on the machine where it was running on the previous time slot, to avoid unacceptable runtime discontinuities and job/VM failures. This implies the necessity of re-running a new constrained scheduling problem with the obvious consequences in terms of convergence latencies and reduction in effectiveness. For these reasons, to keep the basic model as simple as possible and contain the simulation times, such elastic behavior has not been implemented in the current proof of concept architecture. In any case, each running task (and hence its associated user) is charged by the cloud provider for the time slots it runs on a specific machine at a flat rate ρ per ‘‘computing power’’ unit. All the machines are considered to be equivalent in terms of utilization charge. • a certain number of resource providers P owning the machines in M and offering their service on the Cloud, so that the machine in M are partitioned into P disjoint sets V1 , V2 , . . . , VP so that: P 

Vi = ∅ and M =

i =1

P 

Vi .

Si = {(Ji,1 , mp ), (Ji,2 , mq ), . . . , (Ji,t , mz )} (2)

i=1

The end-users can be considered generic entities requesting services to the Cloud by using properly designed web interfaces (service portals, APIs etc.) and middleware services, usually implemented through the Web Services standards. In the proposed game-theoretic approach, to each end-user is associated an autonomous agent, acting as an interface to the cloud runtime framework, that can be viewed as a player in a job scheduling game, that will assist him in finding suitable resource to run its tasks. The resource providers need to maintain a certain level of resource utilization to cover the renting and managing costs and gain sufficient profit (they charge the Cloud provider for individual machine usage). Ideally each resource provider c, to achieve its optimum profit, should aim at maximizing the usage of its machines mi ∈ Vc , that is: max

 

xj,k (i) · pj,k .

(3)

j∈U k∈Jj mi ∈Vc

However, since different resource providers may apply different charges to the cloud providers for their services, their own performance/gain objectives may be in contrast with the cloud providers’ ones. If we assume that, in each time slot 1t, a Cloud provider is charged by the resource provider c at a flat rate πc < ρ per computing power unit for the utilization of each machine mi ∈ Vc , the fundamental cloud provider’s objective is maximizing its total revenue, expressed by: max

  j∈U k∈Jj

mi ∈

P 

xj,k (i) · (ρ − πc ) · pj,k .

(4)

Vc

c =1

To reflect the aforementioned different providers’ objectives, to each machine mi is associated a cost function gmi (x) whose value dynamically changes according to its utilization level x. In particular, a queue of requests for service is associated with each shared machine and the above cost function gmi (x) may increase depending on the number x of agents that want to use that specific machine to run their tasks. In detail, the provider cost function g (·) for a machine mi currently required by x agents is modeled as: gmi (x) = (πc − ρ) ·



wi − x si · w i



where mi ∈ Vc .

Accordingly, the cost of using a resource mi ∈ M grows with the price that the cloud provider must pay to the involved resource provider c for using that machine (that affects the first product term in Eq. (5), accounting from the cloud provider’s own objective) and is reduced when the usage of the machine mi increases (due to the second term in the equation, favoring the machine utilization, in fulfillment of the resource provider’s objective). Each user ui can be associated to an autonomous agent, whose task is choosing the machine on which each of its jobs have to be processed. Henceforth the terms user, player and agent will be used interchangeably. The autonomous agents are self-interested and welfare-maximizing, according to a pure strategic behavior, and hence their unique goal is determining a scheduling strategy Si aiming at optimizing their own utility, which may occur at the expense of the others and of the overall Cloud system welfare. A strategy Si can be defined as a complete set of associations among all the t jobs associated to a specific user ui and the available machines. That is:

(5)

| {xi,1 (p) = 1, xi,2 (q) = 1, . . . , xi,t (z ) = 1}

(6)

with p, q, z ∈ {1, 2, . . . , |M |}. Each job Jj,k to be completed on a machine mi requires an initial p q data transfer time bj,k plus a processing time sj,k . We can quantify i i the utility of an individual agent ui associated to a scheduling strategy Si as a negative function υi (Si ) of the completion time of the associated set of jobs Ji according to the specific strategy Si , that is:

υi (Si ) = −





qj,k bm

(Jj,k , m)∈Si

+

pj,k



sm

.

(7)

In other words, the more time an agent takes to complete its task set according to the strategy Si , the greater will be its incurred cost. Clearly, each user/agent ui is not isolated and its actions influence and are influenced by the actions of the others. Accordingly, they must be forced to interact in order to generate a global schedule S = (S1 , . . . , Sn ) in which all the agents have their jobs processed on the Cloud. The individual component strategies Si ∈ Si∗ , where Si∗ denotes the set of all the possible strategies available for the user ui , define the actions to be chosen by the associated agent for a possible scenario that it can experience. Each global schedule S, defined in S ∗ = S1∗ × S2∗ ×· · ·× Sn∗ , that according to the game theory can be referred as a global strategy profile, represents a combination of strategies for all the players and hence specific state of the scheduling game. Furthermore, since users’ strategies indirectly affect the providers’ utility (users, for running their jobs, pay the cloud provider that in turn is charged by the resource providers involved within the federated organization), the individual user utility should also be conditioned by the (sometimes conflicting) providers’ objectives. To reflect this, the providers’ costs Gm (Si ), associated to the selection of a machine m within the strategy Si , have to be introduced in the utility function υi (Si ) to impose some incentives to user strategies that strive to be compliant to providers’ resource management objectives and strategies. This results in the new redefined υi (·) utility function:

υi (Si ) = −

 (Jj,k , m)∈Si



qj,k bm

+

pj,k sm



· Gm (Si ).

(8)

In the above Eq. (8), the function Gm (Si ) can be calculated from the providers’ cost function gm (x) presented in Eq. (5), where x is

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

the number of jobs running on the machine/resource m within the strategy Si , according to:

           Gm (Si ) = gm xj,k (m)  .   (Jj,k , m)∈Si

(9)

In addition, since there is no a priori motivation for cooperation between the agents associated to the users ui ∈ U, their own utility objectives (minimizing the cumulative run time for the job set associated to ui ), expressed in terms of the Eq. (8) per-user utility functions: max υi (Si ),

(10)

Si ∈Si∗

only depend from the individual users’ strategies and hence are in conflict. Anyway, in lack of any central coordination mechanisms, a global schedule resulting from the above interactions may not efficiently share the machines. Clearly, the utility Υi (S ) associated to each user ui in a global schedule S = (S1 , . . . , Si , . . . , Sn ) is only related to its specific strategic choice Si . Thus, when referring to the individual user utility for a global schedule S representing a game state or strategy profile we can assert that:

Υi (S ) = υi (Si ).

(11)

We are interested in conditioning the strategies unilaterally chosen from each user/player to obtain a global schedule that optimizes the social utility, that is a form of compromise, sharing the maximum combined achievable utility for all the players and providers. This means finding, starting from the strategy profiles Si ∈ Si∗ for all the users a global schedule S ∈ S ∗ so that S = arg max S ∈S ∗



υi (Si )

(12)

i∈U

which is the solution (or state) presenting the maximum social utility, where the social utility associated to a single state S is expressed by:

Υ (S ) =



υi (Si ).

(13)

i∈U

Starting from the strategy profiles for all the users/players and given a set of the strategies unilaterally chosen from each player, according to the aforementioned utility criteria, we say that, the game is in an equilibrium if no player can increase its own welfare by changing its choices. This equilibrium concept was first introduced by John Nash [31] and it is known as Nash equilibrium. Such equilibrium defines a fundamental point of stability within the system, because no player can unilaterally perform any action to improve its situation. It is very interesting to explore the existence of pure Nash equilibria (PNE) in this scheduling game: a strategy profile or global scheduling S = (S1 , . . . , Si , . . . , Sn ) can be considered a pure Nash Equilibrium if for each player ui and for all the alternative strategies S ′ = (S1 , . . . , Si′ , . . . , Sn ). With Si′ ∈ Si∗ differing only in the ith component it holds that:

Υi (S ) ≥ Υi (S ′ ).

(14)

The concept of Nash Equilibrium is in some sense the analog of centralized optimal design in the context of multiple distributed selfish participants. We are very interested in finding such equilibria, or points of stability within the scheduling game. In other words, it is highly undesirable that the job to machine mapping keeps changing and the overall Cloud system performance can be adversely affected if players continuously keep reacting to one another’s strategy changes. It has been demonstrated that, for each job scheduling

1465

game in which a finite number of players (users/tasks) can be assigned to a finite number of machines there exists at least one pure-strategy Nash equilibrium [32]. Since each Nash equilibrium is the outcome of a process in which selfish, rational agents try to optimize only their own individual utility, such an equilibrium state (pure or not) does not necessarily optimize a global goal, that is achieving the optimal utility for a game: opt = max Υ (S ).

(15)

S ∈S ∗

In line of principle, among all the possible pure Nash equilibria, we are interested to find the best one, that is the one that maximizes the social welfare by achieving the optimal utility opt defined above. However, this is not always possible, at least in computationally acceptable times, and thus we can limit ourselves to determine an equilibrium state that tends to approximate, in terms of performance, the best one. This can be accomplished iteratively, according to a stepwise process, by progressively refining the performance/quality of the determined solution until a properly chosen acceptance threshold is reached. Typically, this threshold is empirically associated to a reasonable number τ of successive iteration steps in which no improvement is achieved on the global utility and hence on the performance of the solution. The global performance of Nash equilibria within the context of a specific problem/game is measured by the so-called Price of Anarchy (PoA) or coordination ratio which is defined as the ratio of the utility of the worst Nash equilibrium over the optimal solution [33], and reflects the loss in the global game performance due to the lack of coordination among players: min Υ (S ) PoA =

S ∈N

(16)

opt

where N is the set of all the Nash equilibria over the involved game. Another performance metric for evaluating the impact of searching a stable solution, is the price of stability, introduced in [34,35]. It is defined as the ratio of the objective function in a best Nash equilibrium and a global optimum schedule and hence can be considered as an optimistic price of anarchy [33]. max Υ (S ) PoS =

S ∈N

opt

.

(17)

PoS is particularly significant for games in which there is some inherent mechanism/authority that can directly or indirectly influence the players in some way, and can be viewed as a measure of the benefit introduced by such influence. In some applications it is possible to determine for it a nontrivial bound and in presence of multiple equilibria it assumes values very close to one. According to [36] in job scheduling problems formulated consistently with the theoretical congestion model (a job is released by a machine after all the jobs in that machine have been processed) the POS is known to be 1 and hence there always exists a pure Nash equilibrium which is an optimal solution. Clearly, a game with a low Price of Anarchy can be reasonably left almost unconditioned, since the involved selfish players – by virtue of being selfish – are guaranteed to achieve an acceptable performance. Several works in the literature [37,33] showed the presence of tight upper and lower bounds on the price of anarchy in specific simplified job-scheduling models, such as the one proposed by Koutsoupias and Papadimitriou (KP-model) [33]. However, in more general formulations of job scheduling games there is no certainty of a bound in the PoA. On the other hand, in presence of a higher Price of Anarchy, and hence of a significant chance of conflict among players’ objectives, it is necessary to introduce some other incentives for them, implicitly working as social control and coordination mechanisms, that influence the players’ selfish choices and hopefully force them to collaborate more efficiently.

1466

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

4. The agent-based selfish scheduling system Nash Equilibria may be an extremely powerful tool to obtain fully distributed solution to resource scheduling problems in competitive cloud environments, where the available computing resources and the tasks to be run on them may be owned by different strategic entities, who are typically interested in optimizing their own objective rather than the global one. Accordingly, we modeled a distributed scheduling system driven by game theoretic considerations and based on autonomous selfish agents acting as ‘‘runtime brokers’’ for each client requiring cloud services. Such broker agents, providing a high-level interface to exploit the cloud execution capability, are implemented at the cloud Platform as a Service (PaaS) level to handle the discovery and submission of incoming tasks as well as the selection of available runtime resources on the cloud. Each agent, that must be resource-aware and able to express its resource needs to the system and perform allocation/deallocation accordingly, lives until the associated tasks executes on a cloud runtime resource, or is waiting for being executed in the next time slots, and will be dissolved when all its tasks are completed and the results are sent to the end user. However, once accomplished its complete job allocation, an agent stops participating to the scheduling game in the next time slots and stays alive only for releasing its associated resources after each job termination. Agents aim at designing the best schedule optimizing their own utility, that is the one using the most powerful machines and minimizing the associated cost, without collisions with the tasks assigned to other agents. Cloud providers, on their own, aim at executing all the jobs and at optimizing the resources utilization in order to get the maximum profit. There are no super-local resource brokers or centralized control entities and the assignment of all the resources available within the Cloud is totally under the control of the aforementioned selfish agents, to implement a totally distributed and highly dynamic scheduling environment to allow scalable, failure-safe and improved resource utilization. The intrinsic nature of Agent technology, explicitly oriented to model high dynamic and complex systems, has features well fitting to handle distributed decision processes. We mean that, it allows us to model the agents’ ability of organizing themselves, despite their selfish objectives, and of adapting dynamically to changing circumstances without top-down control from a central control logic. Due to their reactivity and pro-activity features, agents are also very reliable components to build fail-safe systems, since their autonomous behaviors easily allow recovering from fault conditions. 4.1. Coping with selfishness: introducing marginal costs Typically, a global schedule motivated only by selfish considerations does not minimize the total makespan, that is the maximum completion time of all the job instances in the schedule (bounded by the computational burden on the most loaded machines), and the Flowtime, referring to the response time to the user petitions for task executions, and consequently is not able to achieve a social optimum. This is due to the fact that, the local decisions taken by non-cooperative selfish agents with conflicting interests do not possess any type of global optimality. In other words, the total lack of regulation and cooperation has the implicit effect of decreasing the overall system performance. Conflicts may arise among multiple players every time they select for job execution the same machine mi ∈ M with no sufficient runtime or storage capacity. In this case, the strategy Sj associated to each player’s selfish decision process will present one or more clashes between the (Jj,k , mi ) association pairs, that have

to be fixed, by forcing proper strategy changes, in order to achieve a feasible scheduling solution. Such changes should minimally affect the agents’ selfish objectives and hence should have the minimum possible impact on their individual utility function values. Thus, the results of multiple selfish decision processes can only be improved by introducing some form of coordination. The inefficiency of non-cooperative decision processes (and, more generally, of Nash equilibria) motivates the need of strategies for coping with selfishness, that is, specific methods/techniques influencing the game in such a way that, non-cooperative behavior results however in a socially desirable outcome. These methods usually operate by introducing some form of incentives for the players, properly weighting the proposed strategies by keeping into account the impact of all the proposals/strategy profiles, to influence the agents’ selfish choices, hopefully driving to a satisfactory scheduling solution. These incentives can be naturally modeled by non-negative per-unit taxes (or prices) assigned to the individual machine resources with the sake of encouraging cooperating strategies. Such taxes become additional cost factors, also known as ‘‘marginal costs’’ adversely conditioning the users’ utility function, to drive the decision process for each agent/player uj towards a social optimum. Simply stated, the player’s cost for adopting a specific strategy Sj should be calculated by adding such marginal cost associated to choosing a machine resource mi to the natural cost due to the resource’s congestion. The principle of such marginal cost model asserts that every player, on each machine selected in its scheduling plan, should pay a tax proportional to the additional social cost its presence causes for the other players selecting the same resource within their strategy. Consequently, each conflict on a specific machine results in an increased cost whose module is additively proportional to the number of individual agents’ strategies that have chosen that machine to run their jobs. The use of proper marginal cost function can result in an indirect coarse-grained load balancing effect since each job tends to be dispatched to a cloud resource that has less workload to better meet the users’ execution demands. Designing optimal taxes is a central topic in game theory. These taxes have to be conceived as an implicit coordination mechanism implemented by using a cost function properly chosen according to a ‘‘coordination model’’ as defined in [38]. Marginal costs must be efficiently computable according to a stepwise process, which can progressively drive the convergence towards an equilibrium solution, and make the Nash equilibria of the modified game coincide with a solution that is the nearest possible to the optimal one. In general, any equilibrium reached by the selfish players who are conscious of both the resource usage costs and the additive taxes will minimize the social cost [39]. According to [40], the marginal cost associated to a resource m can be additively associated to the providers’ cost function gm (·) defined in Eq. (5) in such a way that at the step n the value of the (n) function gm (·) = gm (·) will be defined as: d (n) gm (x) = gm(n−1) (x) + x · gm(n−1) (x). dx

(18)

In detail, the marginal costs associated to the machine mi , currently used by x agents, incremented on each selection of mi within an agent strategy Sj will be defined, at each addition step, as the first order derivative of the function gmi (x) presented in Eq. (5): d dx

gmi (x) = −

πc − ρ si · w i

where mi ∈ Vc .

(19)

Clearly, since πc < ρ for each provider c ∈ {1, . . . , P }, this is a positive quantity, that can be considered as the aforementioned additional tax paid for each selection of the machine mi in a specific

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

strategy Sj . Observe that, the Eq. (18), describing the additive effect of marginal cost, increasing with the load/number-of-conflicts on the machine mi , is composed by a first term, which captures the additional social cost introduced by the other players’ strategies choosing mi , and a second one, accounting for the increased cost due to the specific strategy Sj . Although these additional costs increase the players’ own ‘‘expenses’’, they do not influence the overall social cost, because the damage in terms of additional cost for a player corresponds to a gain for another one, and their cumulative effect is null within the whole strategy space S ∗ , so that they can be considered as payments remaining inside the system that can be indirectly ‘‘refunded’’ to the players in terms of bonus, or strategic gain, associated to each feasible solution [41]. In addition, marginal costs have a scope limited to the duration of a single time slot, so that, at the start of each new time slot, when a new scheduling problem/game has to be solved and a new equilibrium found, they are recalculated from scratch based on the new game’s strategies. The implemented taxation scheme seems to be efficient enough to achieve the desired result. In other words, the additional ‘‘disutility’’ caused by the taxation is approximately proportional to the desired goal, that is, determining a global schedule that minimizes the total makespan. 4.2. Converging towards a Nash equilibrium The distributed scheduling algorithm, on each time slot, iteratively strives to transform a non-equilibrium configuration into a pure Nash equilibrium through a sequence of greedy selfish steps, where each agent, starting from the current resource allocation status, proposes a solution that minimizes its cost. Each step consists, for each agent, in re-computing its scheduling strategy with respect to the choices selfishly made by the other players, by potentially changing some of its previous choices and diminishing its own utility/performance υi (Si ) to cope with conflicts. That is, each agent/player iteratively computes its local scheduling strategy by indirectly keeping into account (thanks to the marginal costs mechanism) the selfish choices of the other players competing on the same resources. In detail, on each iteration step of the distributed algorithm, each agent uj calculates its minimum cost scheduling strategy Sj in a pure selfish way (by using a First-Fit bin-packing scheme, for example), without considering the other agents’ choices, advertises it on the inter-agent communication network and simultaneously learns, from the received advertisements, the strategies proposed by the other agents, so that it is able to construct a tentative scheduling profile S = (S1 , . . . , Sn ) containing the strategies proposed by all the valid players operating on the cloud. The profile S is not still a valid state of the game, until there are conflicts in resource assignment among the different agents’ proposals that make it an incomplete or invalid solution. For each association (Jj,k , mi ) ∈ Sj , the relative costs reported in Eq. (8) are recalculated, by upgrading the associated marginal cost component gmi (·) according to Eq. (18), to implicitly charge each machine resource for the congestion effects caused by its presence within one of the agents’ scheduling strategies. As, already asserted in the previous section, these additional costs, proportionally taxing each machine mi within the schedule S according to the global demand (end hence the degree of conflict) have the effect of mitigating (and in the best case, even suppressing) the performance degradation due to the selfish and non-cooperative behavior of the independent players. In presence of ‘‘collisions’’ on some resources a new scheduling strategy Sj′ is recomputed by all the conflicting agents uj by substituting an element (Jj,k , mi ) in the strategy Sj in such a way

1467

that the loss in local utility for the agent uj is minimized: Sj′ ← {Sj \ (Jj,k , mi )} ∪ {(Jj,k , mx )} | mx

  = arg min υj (Sj ) − υj (Sj′ ) . mk ∈M

(20)

The above process is iterated by upgrading at each step the marginal costs on each selection basis, until no more conflicts are present and a valid problem solution S ∗ is obtained. Then, starting from the global solution S ∗ new solutions are iteratively computed by forcing each agent to change its strategy, by substituting a single element (Jj,k , mi ) as in Eq. (20), so that the global utility Υi (S ∗ ) is possibly incremented. Clearly, each strategy change for an individual agent in our competitive resource allocation game may create new conflicts and influence the utilities of several other agents, thus implying the recalculation of marginal costs. The process terminates when an equilibrium is reached and no one of the participating agents is interested in changing (otherwise its utility will decrease) its own task allocation strategy. This is experienced when no improvement is achieved on all the individual users’ utilities Υi for more than τ successive iteration steps, where τ is the threshold value introduced in Section 3. Sometimes, typically when the system is overloaded and there are no sufficient resources to cope with the current demand, an equilibrium solution cannot be found since there are no possible system states (and hence global schedules) presenting no collisions between agents. In these cases, the process terminates when a fixed maximum number of iteration ζ is reached and collisions are still present, by resulting in a partial solution where all the agents’ tasks colliding on each resource mi ∈ M, except the ‘‘oldest’’ one (the one whose expiration time is closest to its deadline), are shifted on the next time slot. An extremely simplified pseudo-code representation of the whole process is reported in Algorithm 1. 4.3. The agent communication facility We have to consider that whenever each player tries to minimize its private cost, we need a common decision point where each individual strategy Si has to be communicated to all the other agents, letting them to build the global schedule S = (S1 , . . . , Sn ) required to construct a final equilibrium solution within the scheduling game. Consequently, all the Broker Agents operating within the federated cloud system must be able to exchange the aforementioned strategy information by using a common communication protocol and a unique data model for representing the involved (task, resource) pairs. To stress the concept of complete independence among broker agents, we structured the communication facility in order to allow all the agent-to-agent interactions to take place exclusively via indirect asynchronous communication, implemented by publishing (and hence broadcasting) all the information to be exchanged on a Peer-to-Peer Kademlia-like [42] overlay communication network. The Publishing of a scheduling strategy by each Broker Agent is implemented as a sequence of simple ‘‘STORE’’ messages on the Kademlia network, corresponding to individual pairs/elements (Jj,k , mi ) in the task–resources allocation plan, at a specific step, defined according to Eq. (6), where the job information Jj,k univocally identifies the associated agent and the candidate machine mi is used as a key, so that the collisions can be easily detected through multiple ‘‘FIND VALUE’’ operations. The effectiveness of using peerto-peer overlay organizations to support job scheduling in Clouds has been discussed and extensively evaluated in [43]. The Broker agents are also aware, through the same facility, of the global Cloud topology described in terms of the resources available and their associated costs. Such information is published

1468

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

Algorithm 1 Selfish-Scheduling(U , J , M , τ )

Table 1 Topology extension and task number dimensions used in experiments.

Input: U: users/agents set J: jobs/tasks set M: machines set τ : acceptance threshold value ζ : maximum number of iterations Output: S: resulting equilibrium solution 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:

S←∅ for all agents ui ∈ U do Si ← Selfish_Schedule(ui ) S ← S ∪ {Si } {publish Si into P2P Information Network} end for S∗ ← S N step ← 0 {number of steps with no agents interested in changing} T step ← 0  while T step < ζ and (∃ (Sj , Sk ) ∈ S ∗  Conflict (Sj , Sk ) = true or N step < τ ) do S ← S∗ Update_Marginal_Costs(S )  Sj′ ← {Sj \ (Jj,k , mi )} ∪ {(Jj,k , mx )}  mx = arg min |υj (Sj ) − mk ∈M

13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25:

υj (Sj′ )| S ∗ ← {S \ Sj } ∪ {Sj′ } N step ← N step + 1 for all agents ui ∈ U do if Υj (S ∗ ) > Υj (S ) then N step ← 0 {at least an agent is interested in changing} end if end for T step ← T step + 1 end while if T step = ζ then Remov e_Conflicts(S ) {shift conflicting tasks on next slot} end if return(S )

on the Peer-to-Peer Kademlia-like network by the Cloud provider and dynamically kept up-to-date on each topology change (when new resources join or leave the Cloud or when their costs and/or usage status changes). Such an indirect broadcast communication solution has good scalability characteristics while requiring minimum synchronization among the agents, due to its extremely simple protocol, highly predictable key research, robustness against node failures and DHT (Distributed Hash Tables)-based architecture [44]. 5. Experimental analysis and performance evaluation In order to evaluate the functionality and effectiveness of the proposed distributed scheduling framework, we conducted an extensive simulation study by working on a simplified proofof-concept implementation of the competitive federated Cloud environment. The obtained results have been briefly discussed to show and emphasize the potential benefits achievable through the presented approach as long as its weaknesses and pitfalls.

Machines and/or Sites

Tasks

Workload capacity Slots available

Workload demand Slots required

10 20 30 40 50 60 70

50 100 200 300 400 500 600

500 1000 1500 2000 2500 3000 3500

250 500 1000 1500 2000 2500 3000

prototyped version of jKad [46], a publicly available open source implementation of the Kademlia protocol released under GNU Lesser GPL. Each experiment in our performance analysis has been replicated 100 times (to acquire the necessary confidence – targeted to 95% – in the results), on random-generated Cloud topologies, with a varying number of concurrent agents and tasks per agent and increasing load in terms of resource demand. Since simulations have been run on a single machine, while in a real implementation all the agents activities will be distributed (and hence run in parallel) on different machines, in order to analyze in terms of space and time complexity the performance of the distributed scheduling scheme, we estimated the average number of iterations/negotiation steps needed for converging to an equilibrium solution. In addition, to study the impact of the agents’ selfish behavior, we also empirically calculated in each experience the ‘‘surrogate’’ per-solution price of anarchy as long as the average agent’s utility loss of the distributed solution respect to the approximated optimal one calculated in a centralized way by using a first-fit greedy approximation algorithm. The inter-machines networking capabilities, described by the bandwidth bi (per-machine interconnection capacity) and the machines’ workload (wi ) and storage capacities (di ) have been randomly generated by ensuring the availability of an average of 50 available slots per machine. We assumed that, the same number of tasks t, whose computational and storage requirements pi,j and qi,j are generated randomly, is assigned to each broker agent. The runtime resources available on the cloud have been kept heterogeneous in terms of computational power and storage, and progressively saturated by an increasing number of tasks. However, some of the experiments, aiming at studying the scalability of the proposed scheme, have been run by simulating increasing load conditions on progressively greater topologies in such a way that sufficient room on the runtime resources set has always been left and hence at least a feasible global solution to the scheduling problem has been available in each test run. In other words, the cloud runtime resources grew proportionally with the number of tasks, so that we started with a small infrastructure with 10 networked machines and a demand of 50 tasks to be run, and progressively increased the simulated problem dimensions, by ensuring that the agents’ demand never exceeded the available resources as reported in Table 1. Finally, a unique value of the acceptance threshold τ = 3 has been used in all the presented results since no significant performance improvements were achieved with larger values (we ran all the experiments with τ values in {3, 5, 7}) whereas the convergence of the process was adversely affected in a perceivable way. The maximum number of iterations ζ has been fixed to a value of 500 steps.

5.1. The proof of concept simulation testbed 5.2. Results and discussion In order to validate the proposed model, we developed a simple simulation testbed using the ProtoPeer [45] platform. To model the Peer-to-Peer overlay communication facility we have used a

We analyzed the relation between the number of steps necessary to solve any conflicts between the selfish strategies of

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

1469

Fig. 1. Number of steps needed for convergence with increasing load.

the individual agents and converge to a global equilibrium strategy, and the total number of tasks, representing the current load of the overall scheduling system. In a first experiment, we let the total number of tasks progressively increase together with both the number of competing agents and the number of tasks per agent, to study the convergence of scheduling system, when the demand/load grows. The total amount of available resources is fixed to the maximum values reported in the last line of Table 1. Fig. 1 plots the results for all the runs of the above experiment, analyzing the number of steps needed for convergence, where the load regularly increases with the number of agents (ranging between 8 and 29) and the number of tasks per agents (ranging from 3 to 19) until a maximum total number of 551 tasks to be scheduled is reached. We do not aggregate the achieved results to make more evident their extremely regular distribution around a common trend line. While not distinguishing between the individual runs, we can observe that, the number of steps required grows almost linearly with the number of tasks, until the emergence of a phase transition towards a rapid exponential growth when the global demand approaches the amount of resources available (the total number of tasks surpasses 90% of its maximum) and hence the available workload capacity becomes scarcer and scarcer. We also fixed the number of agents (concurrency degree) at several constant values and varied the number of tasks assigned to each agent, by observing that (see Fig. 2), for each specific number of agents, the number of steps necessary to agree on a global schedule grows linearly with the number of tasks per agent until the available resources largely exceed the demand (our original assumption in dimensioning the tests). After that we can observe, as in the previous example, a rapid change to an exponential growth trend. This happens in a significantly shorter task increment lapse where the number of agents is fixed to a greater value whereas, in presence of a limited number of agents, such degradation effect is much slower and hence less evident. To be more readable, Fig. 2 reports the average values computed at all the 100 runs of the experiment. Analogously, we fixed the number of tasks per agent and studied the convergence of the scheduling system when the number of agents varies. Fig. 3 shows that the average number of steps needed to converge still depends linearly from the number of agents, but this dependence becomes more relevant as the number of tasks increases. In a second experiment, to observe the system behavior without the biasing effect of resource saturation, we increased the number of agents without changing the ratio between the demand and the available resources (by keeping it fixed to a constant value of 50%) and keeping the total number of tasks fixed to a value of 320. In Fig. 4 we can see that, a greater number of agents allows more conflicts to be solved at each step, causing the total number of steps to decrease, and the convergence process being improved, when the number of agents grows. Analogously, by fixing both the number of task per agent and the demand/available resources ratio to a constant value and letting the number of agents and the total number of tasks vary,

Fig. 2. Average number of steps needed for convergence with increasing number of tasks per agent.

Fig. 3. Average number of steps needed for convergence with increasing number of concurrent agents, fixed number of tasks per agent, fixed amount of available resources.

Fig. 4. Average number of steps needed for convergence with increasing number of agents, constant number of total tasks (=320) and 50% demand/available resource ratio.

we can observe (see Fig. 5) that the number of steps needed to converge increases with a logarithmic trend. The demand/available resource ratio is kept constant by progressively increasing the amount of available resources. This scenario simulates the effect of an increasing workload, but in presence of always same quantity of resources available.

1470

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

Fig. 5. Average number of steps needed for convergence with increasing number of task, constant number of tasks per agent and constant demand/available resource ratio.

Fig. 7. Average per-solution price of anarchy.

Fig. 6. Loss in social utility with increasing number of agents.

We also studied the effects of the fully distributed scheduling logic. The loss in utility consequent to the distribution of the Υ (S

Fig. 8. Price of anarchy with increasing number of agents, constant total number of tasks and 50% demand/available resources ratio.

)

solution, computed as the ratio Υ (opt between the social utilities S) (as described in Eq. (13)) of the approximately optimal centralized solution (Υ (Sopt )) and the selfish distributed one (Υ (S )), is shown in Fig. 6. Fig. 6 refers again to the first experiment, where the maximum amount of available resources is fixed, but both the number of agents and tasks per agent change. In the figure we reported the results for all the individual runs, so that each dot represents the value of the above ratio resulting by one of the 100 tests. We can observe that, the distance from the optimal solution grows when the quantity of available resources decreases due to the increasing load. However, the trend of such degradation phenomenon evolves almost linearly with a very low derivative. To study the performance loss and the oddities introduced by the agents’ selfishness, we empirically calculated the surrogate per-solution Price of Anarchy, as the ratio between the utilities of the current solution and that of the approximated optimal one. In Fig. 7 we fixed the number of tasks per agent and studied the average values of PoA computed on 100 simulation runs when the number of agents varies, as in the first experiment scenario. We can see that, the PoA depends always linearly on the number of concurrent agents, while the number of tasks per agents introduces only a slight shift on the graphic trend. It is worthwhile observing that, when the resources available largely exceed the demand the price of anarchy shows only a 10%, degradation respect to the optimal solution. When instead, under an increasing load, the number of iterations needed to converge begin to increase exponentially (see Fig. 1), the maximum degradation only reaches 12%. We then analyzed the evolution of the per-solution price of anarchy of the second experiment, with an increasing number of agents by keeping the available resource and total number of tasks constant with a ratio between the demand and the available resources of 50%. In particular in Fig. 8 we can see that, the PoA grows very slowly with the number of agents if the amount of available resources does not decrease. Finally, we compute the PoA, still in the second experiment scenario, where only the number of task per agent is kept constant, and the total amount of resources grows to ensure that the

Fig. 9. Price of anarchy with increasing number of agents, constant number of task per agent and 50% demand/available resources ratio.

demand/available resources ratio is constantly equal to 50%. In Fig. 9 we can observe that, the per-solution price of anarchy decreases because there are more resources available for every agent. 6. Conclusions In this work a new agent-based game-theoretic scheme for scheduling computing services within non-collaborative federated Cloud infrastructures has been presented. It exploits the competition dynamics among the federated entities involved to converge towards Nash equilibrium solutions, accounting for the inherently contradicting interests of the clients and the service providers within the Cloud, without the need of any centralized control. Agents confer the needed degree of autonomy to the system components and implicitly introduce global properties like adaptation, self-organization and resilience that make such a solution particularly attractive from the peer-to-peer Cloud scheduling perspective. In fact, there is no need in such an architecture of specific rules for coping with initial conditions, unforeseen scenarios, and variations in the environment or presence of failures. We investigated the effectiveness of the proposed approach by implementing a simple simulation testbed that emulates the Cloud providers and the broker agents together with their communication facility and network protocols. The experimental results validate our hypothesis that a competitive selfish approach, in distributed scheduling environments, does not only achieve

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

a satisfactory solution both in terms of quality/optimality and scalability, but it can also lead to substantial performance gains in terms of completion time, in particular when the problem scales towards very large cloud organizations with a lot of machines and tasks to be served. In these cases, a fully distributed solution with the effect of partitioning a complex and computationally intractable problem in many smaller and more manageable ones becomes a real and indispensable benefit. References [1] D. Fotakis, S. Kontogiannis, P. Spirakis, Selfish unsplittable flows, Theoretical Computer Science 348 (2005) 226–239. [2] D.S. Hochbaum (Ed.), Approximation Algorithms for NP-Hard Problems, PWS Publishing Co., Boston, MA, USA, 1997. [3] V.D. Martino, M. Mililotti, Sub optimal scheduling in a grid using genetic algorithms, Parallel Computing 30 (2004) 553–565. http://dx.doi.org/10.1016/j.parco.2003.12.004. URL: http://dl.acm.org/citation.cfm?id=1016308.1016310. [4] J. Carretero, F. Xhafa, Using genetic algorithms for scheduling jobs in large scale grid applications, Journal of Technological and Economic Development 12 (2006) 11–17. [5] A. YarKhan, J. Dongarra, Experiments with scheduling using simulated annealing in a grid environment, in: Proceedings of the Third International Workshop on Grid Computing, GRID’02, Springer-Verlag, London, UK, 2002, pp. 232–242. URL: http://dl.acm.org/citation.cfm?id=645442.652662. [6] A. Abraham, R. Buyya, B. Nath, Nature’s heuristics for scheduling jobs on computational grids, in: Proceedings of the 8th IEEE International Conference on Advanced Computing and Communications, ADCOM 2000, 2000, pp. 1–8. [7] G. Christodoulou, E. Koutsoupias, A. Vidali, A lower bound for scheduling mechanisms, in: Proceedings of the Eighteenth Annual ACM–SIAM Symposium on Discrete Algorithms, SODA’07, Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 2007, pp. 1163–1170. [8] N. Nisan, A. Ronen, Algorithmic mechanism design (extended abstract), in: Proceedings of the Thirty-First Annual ACM Symposium on Theory of Computing, STOC’99, ACM, New York, NY, USA, 1999, pp. 129–140. [9] T.E. Carroll, D. Grosu, Distributed algorithmic mechanism design for scheduling on unrelated machines, in: Proceedings of the 8th International Symposium on Parallel Architectures, Algorithms and Networks, ISPAN’05, IEEE Computer Society, Washington, DC, USA, 2005, pp. 194–201. [10] A. Archer, E. Tardos, Truthful mechanisms for one-parameter agents, in: Proceedings of the 42nd IEEE Symposium on Foundations of Computer Science, FOCS’01, IEEE Computer Society, Washington, DC, USA, 2001, pp. 482–491. [11] V. Auletta, R.D. Prisco, P. Penna, G. Persiano, Deterministic truthful approximation mechanisms for scheduling related machines, in: STACS 2004, 21st Annual Symposium on Theoretical Aspects of Computer Science, Proceedings, in: Lecture Notes in Computer Science, vol. 2996, Springer, 2004, pp. 608–619. [12] N. Andelman, Y. Azar, M. Sorani, Truthful approximation mechanisms for scheduling selfish related machines, Theory of Computing Systems 40 (2007) 423–436. [13] E. Even-Dar, A. Kesselman, Y. Mansour, Convergence time to nash equilibria, in: Proceedings of the 30th International Conference on Automata, Languages and Programming, ICALP’03, Springer-Verlag, Berlin, Heidelberg, 2003, pp. 502–513. [14] J. Bredin, D. Kotz, D. Rus, R.T. Maheswaran, C. Imer, T. Basar, Computational markets to regulate mobile-agent systems, Autonomous Agents and MultiAgent Systems 6 (2003) 235–263. [15] B. An, C. Miao, Z. Shen, Market based resource allocation with incomplete information, in: Proceedings of the 20th International Joint Conference on Artifical Intelligence, IJCAI’07, Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2007, pp. 1193–1198. [16] Y.-K. Kwok, S. Song, K. Hwang, Selfish grid computing: game-theoretic modeling and nas performance results, in: IEEE International Symposium on Cluster Computing and the Grid, 2005, CCGrid 2005, vol. 2, 2005, pp. 1143–1150. [17] S.U. Khan, I. Ahmad, Non-cooperative, semi-cooperative, and cooperative games-based grid resource allocation, in: Proceedings of the 20th International Conference on Parallel and Distributed Processing, IPDPS’06, IEEE Computer Society, Washington, DC, USA, 2006, p. 121. [18] Z.-j. Li, C.-t. Cheng, F.-x. Huang, Utility-driven solution for optimal resource allocation in computational grid, Computer Languages, Systems & Structures 35 (2009) 406–421. [19] J. Londoño, A. Bestavros, S.-H. Teng, Colocation games: and their application to distributed resource management, in: Proceedings of the 2009 Conference on Hot Topics in Cloud Computing, HotCloud’09, USENIX Association, Berkeley, CA, USA, 2009, pp. 1–21. [20] R. Buyya, C. Yeo, S. Venugopal, J. Broberg, I. Brandic, Cloud computing and emerging it platforms: vision, hype, and reality for delivering computing as the 5th utility, Future Generation Computer Systems 25 (6) (2009) 599–616.

1471

[21] L. Burchard, M. Hovestadt, O. Kao, A. Keller, B. Linnert, The virtual resource manager: an architecture for sla-aware resource management, in: IEEE International Symposium on Cluster Computing and the Grid, 2004, CCGrid 2004, IEEE, 2004, pp. 126–133. [22] I. Foster, C. Kesselman, C. Lee, B. Lindell, K. Nahrstedt, A. Roy, A distributed resource management architecture that supports advance reservations and co-allocation, in: Seventh International Workshop on Quality of Service, 1999, IWQoS’99. 1999, IEEE, 1999, pp. 27–36. [23] Q. Snell, M. Clement, D. Jackson, C. Gregory, The performance impact of advance reservation meta-scheduling, in: Job Scheduling Strategies for Parallel Processing, Springer, 2000, pp. 137–153. [24] A. Mcgough, A. Afzal, J. Darlington, N. Furmento, A. Mayer, L. Young, Making the grid predictable through reservations and performance modelling, The Computer Journal 48 (3) (2005) 358–368. [25] I. Foster, A. Roy, V. Sander, A quality of service architecture that combines resource reservation and application adaptation, in: Eighth International Workshop on Quality of Service, 2000, IWQOS 2000, IEEE, 2000, pp. 181–188. [26] B. Sotomayor, R. Montero, I. Llorente, I. Foster, Virtual infrastructure management in private and hybrid clouds, IEEE Internet Computing 13 (5) (2009) 14–22. [27] B. Sotomayor, R. Montero, I. Llorente, I. Foster, Resource leasing and the art of suspending virtual machines, in: 11th IEEE International Conference on High Performance Computing and Communications, 2009, HPCC’09, IEEE, 2009, pp. 59–68. [28] J. Fontán, T. Vázquez, L. Gonzalez, R. Montero, I. Llorente, OpenNEbula: the open source virtual machine manager for cluster computing, 2008. [29] M. Feldman, T. Tamir, Approximate strong equilibrium in job scheduling games, in: Proceedings of the 1st International Symposium on Algorithmic Game Theory, SAGT’08, Springer-Verlag, Berlin, Heidelberg, 2008, pp. 58–69. [30] N. Andelman, M. Feldman, Y. Mansour, Strong price of anarchy, in: Proceedings of the Eighteenth Annual ACM–SIAM Symposium on Discrete Algorithms, SODA’07, Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 2007, pp. 189–198. [31] J.F. Nash, Equilibrium points in n-person games, Proceedings of the National Academy of Sciences of the United States of America 36 (1950) 48–49. [32] R.W. Rosenthal, A class of games possessing pure-strategy Nash equilibria, International Journal of Game Theory 2 (1) (1973) 65–67. [33] E. Koutsoupias, C. Papadimitriou, Worst-case equilibria, in: Proceedings of the 16th Annual Conference on Theoretical Aspects of Computer Science, STACS’99, Springer-Verlag, Berlin, Heidelberg, 1999, pp. 404–413. [34] A.S. Schulz, N.S. Moses, On the performance of user equilibria in traffic networks, in: Proceedings of the Fourteenth Annual ACM–SIAM Symposium on Discrete Algorithms, SODA’03, Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 2003, pp. 86–87. [35] E. Anshelevich, A. Dasgupta, J. Kleinberg, E. Tardos, T. Wexler, T. Roughgarden, The price of stability for network design with fair cost allocation, in: Proceedings of the 45th Annual IEEE Symposium on Foundations of Computer Science, IEEE Computer Society, Washington, DC, USA, 2004, pp. 295–304. [36] L. Agussurja, H.C. Lau, The price of stability in selfish scheduling games, in: Proceedings of the 2007 IEEE/WIC/ACM International Conference on Intelligent Agent Technology, IAT’07, IEEE Computer Society, Washington, DC, USA, 2007, pp. 305–311. [37] A. Czumaj, B. Vöcking, Tight bounds for worst-case equilibria, ACM Transactions on Algorithms 3 (2007) 4:1–4:17. [38] G. Christodoulou, E. Koutsoupias, A. Nanavati, Coordination mechanisms, Theoretical Computer Science 410 (2009) 3327–3336. [39] G. Karakostas, S. Kolliopoulos, The efficiency of optimal taxes, in: Combinatorial and Algorithmic Aspects of Networking, in: Lecture Notes in Computer Science, vol. 3405, Springer, Berlin, Heidelberg, 2005, p. 95. [40] T. Roughgarden, E. Tardos, How bad is selfish routing? Journal of the ACM 49 (2002) 236–259. [41] F. Palmieri, U. Fiore, S. Ricciardi, Selfish routing and wavelength assignment strategies with advance reservation in inter-domain optical networks, Computer Communications 35 (3) (2012) 366–379. [42] P. Maymounkov, D. Mazières, Kademlia: a peer-to-peer information system based on the xor metric, in: Revised Papers from the First International Workshop on Peer-to-Peer Systems, IPTPS’01, Springer-Verlag, London, UK, 2002, pp. 53–65. [43] B. Di Martino, R. Aversa, S. Venticinque, L. Buonanno, Competitive p2p scheduling of users’ jobs in cloud, in: Cloud Computing 2011, The Second International Conference on Cloud Computing, GRIDs, and Virtualization, 2011, pp. 105–112. [44] H. Balakrishnan, M.F. Kaashoek, D. Karger, R. Morris, I. Stoica, Looking up data in P2P systems, Communications of the ACM 46 (2003) 43–48. [45] W. Galuba, K. Aberer, Z. Despotovic, W. Kellerer, Protopeer: a P2P toolkit bridging the gap between simulation and live deployement, in: Proceedings of the Second International ICST Conference on Simulation Tools and Techniques, 2009, pp. 1–9. URL: http://eudl.eu/?id=5681. [46] B. Penteado, Jkad: Java implementantion of the kademlia network. URL: http://code.google.com/p/jkad.

1472

F. Palmieri et al. / Future Generation Computer Systems 29 (2013) 1461–1472

Francesco Palmieri is an assistant professor at the Engineering Faculty of the Second University of Napoli, Italy. His major research interests concern high performance networking protocols and architectures, routing algorithms and network security. Since 1989, he has worked for several international companies on nationwide networking-related projects and, from 1997 to 2010 he has been the Director of the telecommunication and networking division of the Federico II University, in Napoli, Italy. He has been closely involved with the development of the Internet in Italy as a senior member of the Technical–Scientific Advisory Committee and of the CSIRT of the Italian NREN GARR. He has published more that 80 papers in leading technical journals/conferences and currently serves as the editor-in-chief of an international journal and is part of the editorial board of several other ones.

Luigi Buonanno is an Engineer at Ansaldo STS. His working activities deal with validation and test of railway communication and interlocking systems. He has got his Ph.D. in Electronic Engineering in 2012 at Second University of Naples. His research activities focus on Distributed Computing, Cloud and Grid computing, P2P systems. He has been author and reviewer for international conferences on computer science.

Salvatore Venticinque is an Assistant Professor at Department of Information Engineering of the Second University of Naples. He received the Laurea degree in Informatics Engineering in 2000 and his Ph.D. inâ Electronic Engineeringâ from the Second University of Napoliâ in 2003. He taught courses in Computer Programming and Computer Architecture. He is involved in research activities dealing with parallel and Grid computing and Mobile Agents programming for distributed systems. He is author of several publications in international journals, books, and conferences in collaboration with national research organizations and foreign academic institutions (ENEA, University of Vienna). He

participated in research projects (mOSAIC, ISIDE, CRDC-ICT, Serviceware) supported by international and national organizations. In particular, he is Task Leader of mOSAIC project.

Rocco Aversa is an Associate Professor at the Department of Information Engineering of the Second University of Naples. His research interests are in the area of parallel and distributed systems. The research themes include the use of the mobile agents paradigm in the distributed computing and the design of simulation tools for performance analysis of parallel applications running on heterogeneous computing architectures. Rocco Aversa participated in various research projects supported by international and national organizations (EC, MURST, CNR, ASI) and in collaboration with foreign academic institutions; in particular, he is WP leader of mOSAIC project, and he has coordinated the research group of the Second University of Naples in a strategic national research project supported by MURST in the years 1998–2000.

Beniamino Di Martino is currently a Full Professor of Information Systems at the Second University of Naples (Italy) since 2005. He is author of 7 international books and more than 180 publications in international journals and conferences. He is currently Project Coordinator of the FP7-ICT-2010-256910 Project mOSAIC—Open-Source API and Platform for Multiple Clouds. He participated in various research projects supported by national and international organizations. He is vice Chair of the Executive Board of the IEEE CS Technical Committee on Scalable Computing. He is member of the IEEE Working Group on Cloud Interoperability. He is member of the Cloud Standards Customer Council. He is member of the Cloud Computing Experts’ Group of European Commission—Internet of Services, Software and Virtualization Unit. He served as general and program chairman and member, in Program Committees of several international conferences, and as guest editor for several journals’ special issues. He is editorial board member and chair of international journals. His research interests include: Knowledge Discovery and Management, Semantic Web and Semantic Web Services, Semantic based Information Retrieval, Cloud Computing, High Performance Computing and Architectures, Mobile and Intelligent Agents and Mobile Computing, Reverse Engineering, Automated Program Analysis and Transformation, Algorithmic Patterns Recognition and Program Comprehension.