Eugen Feller
email: eugen.feller@inria.fr

Louis Rilling
email: l.rilling@av7.net

Christine Morin
email: christine.morin@inria.fr

Snooze: A Scalable and Autonomic Virtual Machine Management Framework for Private Clouds

Keywords: Cloud Computing, Scalability, Self-Organization, Self-Healing, Virtualization Hierarchical layer Physical layer Local controller

With the advent of cloud computing and the need to satisfy growing customers resource demands, cloud providers now operate increasing amounts of large data centers. In order to ease the creation of private clouds, several open-source Infrastructure-as-a-Service (IaaS) cloud management frameworks (e.g. OpenNebula, Nimbus, Eucalyptus, OpenStack) have been proposed. However, all these systems are either highly centralized or have limited fault tolerance support. Consequently, they all share common drawbacks: scalability is limited by a single master node and Single Point of Failure (SPOF).

In this paper, we present the design, implementation and evaluation of a novel scalable and autonomic (i.e. self-organizing and healing) virtual machine (VM) management framework called Snooze. For scalability the system utilizes a self-organizing hierarchical architecture and performs distributed VM management. Moreover, fault tolerance is provided at all levels of the hierarchy, thus allowing the system to self-heal in case of failures. Our evaluation conducted on 144 physical machines of the Grid'5000 experimental testbed shows that the fault tolerance features of the framework do not impact application performance. Moreover, negligible cost is involved in performing distributed VM management and the system remains highly scalable with increasing amounts of resources.

I. INTRODUCTION

Cloud computing has recently appeared as a new computing paradigm which promises virtually unlimited resources. Customers rent resources based on the pay-as-you-go model and thus are charged only for what they use. In order to meet growing customers resource demands, public IaaS-cloud providers (e.g. Amazon EC2, Rackspace) are now operating increasing numbers of large data centers.

Several open-source IaaS-cloud management frameworks such as OpenNebula [START_REF] Milojicic | OpenNebula: A cloud management tool[END_REF], Nimbus [START_REF] Keahey | Virtual workspaces for scientific applications[END_REF], OpenStack [START_REF]OpenStack: Open source cloud computing software[END_REF], and Eucalyptus [START_REF] Nurmi | The Eucalyptus open-source cloud-computing system[END_REF] have been developed in order to facilitate the creation of private clouds. Given the ever growing computing power demands, they need to scale with increasing number of resources and continue their operation despite system component failures. However, all these frameworks have a high degree of centralization and do not tolerate system component failures. For example, the scalability of OpenNebula, Nimbus and OpenStack is limited by their frontend node/cloud con-troller. Moreover, as no replication support exists, a failure of the frontend node makes the VM management impossible. Similarly, in Eucalyptus each non fault-tolerant cluster controller suffers from the same drawbacks. Last but not least, no VM monitoring is performed thus limiting the support for advanced VM placement policies (e.g. consolidation).

In order to provide scalability and autonomy to virtualized data centers, we proposed Snooze [START_REF] Feller | Snooze: A scalable, fault-tolerant and distributed consolidation manager for largescale clusters[END_REF], a novel VM management framework for private clouds which is designed to scale across thousands of nodes. Unlike the existing cloud management frameworks, Snooze utilizes a self-organizing hierarchical architecture and performs distributed VM management. Particularly, VM management tasks are performed by multiple managers, with each manager having only a partial view of the system. Moreover, fault tolerance is provided at all levels of the hierarchy by replication and integrated leader election algorithm. Consequently, the system is able to selfheal and continue its operation despite system component failures. Finally, VM monitoring is integrated into the framework and a generic scheduling engine exists to support advanced scheduling policies.

The contribution of this paper is as follows. We give an update on the design of Snooze and now present its implementation specific details. Snooze is fully implemented from scratch in Java and currently comprises approximately 15,000 lines of code. Moreover, the framework evaluation is presented. Snooze was evaluated by deploying it on 144 machines of the Grid'5000 experimental testbed and submitting up to 500 VMs. Three aspects were studied: VM submission time in a centralized as well as distributed deployment, overhead of fault tolerance on application performance and scalability aspects. Note, that the evaluation of different scheduling policies is out of the scope of this work. The results show that submission time is not impacted by performing distributed VM management. Moreover, the proposed system remains highly scalable with increasing number of resources and its self-organization properties do not impact application performance.

The remainder of this paper is organized as follows. Section II introduces the design and implementation of Snooze. Section III presents the evaluation of the framework. Section IV discusses related work. Finally, Section V closes the paper with conclusions and future work.

II. DESIGN AND IMPLEMENTATION

This section describes the architecture and implementation of Snooze. First, the system model is presented. Afterwards, a global overview of the architecture is given and the system components are presented. Finally, the self-organization and self-healing mechanisms are described.

A. System Model and Assumptions

We assume a data center whose nodes are interconnected with a high-speed LAN connection such as Gigabit Ethernet or Infiniband. Each cluster can be heterogeneous (i.e. different hardware and software). Each node is managed by a virtualization solution such as Xen [START_REF] Barham | Xen and the art of virtualization[END_REF], KVM [START_REF] Kivity | kvm: the Linux virtual machine monitor[END_REF], OpenVZ [START_REF]OpenVZ[END_REF] which supports VM live migration. VMs are seen as blackboxes which are organized in so-called virtual clusters (VC) where each VC represents a collection of one or multiple VMs hosting one or multiple applications. We assume no restriction about applications: both compute and server applications are supported. Multicast support is assumed to be available at network level. Consequently, complex network topologies supporting multiple clusters are supported given that multicast forwarding can be enabled on the routers. The current implementation of Snooze does not tolerate failures that partition the network. However appropriate leader election algorithms (e.g. [START_REF] Lamport | The part-time parliament[END_REF]) can replace the implemented one to tolerate such failures. Finally hosts may fail, and failures are assumed to follow a fail-stop model.

B. Global System Overview

The global system overview of Snooze is shown in Figure 1. Note that for the ease of explanation this figure focuses on a single cluster while in a real scenario multiple clusters could be managed in the same manner. The architecture is partitioned into three layers: physical, hierarchical, and client. At physical layer, machines are organized in a cluster, in which each node is controlled by a so-called Local Controller (LC).

A hierarchical layer allows to efficiently manage the cluster, and is composed of fault-tolerant components: Group Managers (GMs) and a Group Leader (GL). Each GM manages a subset of LCs, and the GL keeps the summary information of the GMs.

Finally, a client layer provides the user interface. This interface is currently implemented by a predefined number of replicated Entry Points (EPs) and is queried by the clients in order to discover the current GL. Clients can interact with the EPs by utilizing the provided bindings. In order to provide a simple yet flexible interface, all system components are implemented as Java RESTful web services. In the following sections, the details of each component are discussed. Therefore, a LC has two components: Monitor and Actuator. The Monitor implements all the logic required to monitor the host and its VMs, including reporting this information to the assigned GM. Similarly, the Actuator enforces the VM management commands coming from the GM. Both components rely on the Common Cluster Monitoring and Management Interface (CCMMI), which allows to support different virtualization solutions, like the libvirt virtualization management library used in the current implementation, as well as external monitoring frameworks such as Ganglia [START_REF]Ganglia monitoring system[END_REF].

C. System Components

2) Group Managers (GMs): Each node (i.e. LC) of the physical layer is managed by one of the GMs within the hierarchical layer (see Figure 2). This management involves six tasks: (1) receive, store, and answer queries for host and VM monitoring information; (2) estimate VM resource demands; (3) schedule VMs; (4) send VM management (e.g. start, stop) enforcement requests to the LCs; [START_REF] Feller | Snooze: A scalable, fault-tolerant and distributed consolidation manager for largescale clusters[END_REF] transmit GM summary information to the GL; (6) announce its presence.

The host and VM monitoring information supporting the VM scheduling engine decisions is periodically sent to the GMs by the LCs and stored in an in-memory repository (other backends like Apache Cassandra [START_REF] Lakshman | Cassandra: structured storage system on a P2P network[END_REF] can be used to implement this repository).

Based on this monitoring information, VMs' resource demand estimates, that are required by advanced optimization policies like VM consolidation, are performed by an integrated estimation engine using interfaces to support different CPU, memory, and network demand estimators. For instance, a Double-Exponential-Moving-Average (DEMA) (resp. Autoregressive-Moving-Average (ARMA))) estimator can be used to estimate CPU (resp. memory) demand.

VM scheduling is performed on each GM by a generic engine that currently distinguishes between three types of Fig. 2. Hierarchical architecture overview policies implemented by the administrator: (1) scheduling, (2) optimization, and (3) planning. While scheduling policies (e.g. round robin, load balance) are used for the incoming VMs, optimization and planning policies can be used to periodically optimize the VM placement. The optimization policy computes the optimized VM placement and the planning policy computes a migration plan which gives the order of migrations required to move the system from the current state to the optimized one. For example, when the administrator enables continuous optimization and specifies the proper reconfiguration interval (e.g. daily at 1 AM), Snooze attempts to optimize the current VM placement periodically using the pluggable optimization policy (e.g. consolidation). To this end, the engine queries the estimation engine in order to get the current VM resource demand estimates, triggers the optimization and planning policies, and sends live migration requests to the actuators of the LCs. Note, that the evaluation of scheduling features it out of the scope of this paper. GM summary information is periodically sent by each GM to the current GL in order to support high-level scheduling decisions of the GL such as delegating VMs to be scheduled on the GMs, and to detect GM failures. This information is also used in case of GL failure to rebuild the GL system view. Currently, the GM summary includes the aggregated amount of available and used capacity (i.e. CPU, memory, and network) on all the managed LCs, as well as the VM networking related information (see the following sections for more details).

Finally, to support GM failure-detection, each GM is part of a heartbeat multicast group on which it periodically announces its presence.

3) Group Leader (GL): The GL oversees the GMs and fulfills the following tasks: (1) stores incoming GM monitoring summary information; (2) dispatches incoming VC submission requests; (3) assigns joining local controllers to GMs; (4) manages VM network addresses; (5) periodically announces its presence. Note, that unlike on GMs, only lightweight (i.e. dispatching) VM placement decisions are performed. Still, its scalability can be further improved with replication and an additional load balancing layer. GM summary information is received and stored in the GL repository in order to guide VC dispatching as well as LCs to GM assignment. Therefore, the GL integrates a scheduling engine using two types of policies. VC dispatching policies take as input a VM description as well as a repository reference and output the GM to which the VM start request should be delegated. The GL then sends the VM start requests to the assigned GMs, waits for the replies and returns the output (i.e. status of VMs, assigned IP addresses, and GM descriptions) to the caller (see Section II-C5). LC assignment policies take as input a LC description as well as the GM repository reference and output the assigned GM. Passing this references allows to support advanced (e.g. based on GM load) assignment policies. A LC needs to know which GM it is assigned to in order to join the hierarchy (see Section II-D for the details of the join procedure).

VM network management is handled transparently for the user by Snooze. Each GL maintains a system administrator configurable subnet from which it is allowed to allocate IP addresses. When a VC is submitted to the GL, each of its VMs automatically gets an IP address from this subnet. The IP address is then encoded in the MAC address of the VM description before it gets dispatched to the GM. When the VM boots it executes a script which decodes the IP from the VM MAC address and performs the network configuration. A similar approach is applied in OpenNebula [START_REF] Milojicic | OpenNebula: A cloud management tool[END_REF]. In order to let the GL recycle IP addresses, the summary information of a GM includes a list of the IP addresses of its managed VMs that have recently been terminated.

Finally, similar to GMs, the GL announces its presence on a predefined GL heartbeat multicast group.

4) Entry Points (EPs):

The EPs are used by the client software to discover the current GL. In order to keep track of the GL's address, all EPs subscribe to the GL heartbeat multicast group and listen for current GL announcements.

5) Command Line Interface (CLI):

A Java-based CLI is implemented on top of the RESTful interfaces exported by the EPs, GL and GMs. It supports the definition and management of VCs as well as visualizing and exporting the current hierarchy organization in the GraphML format.

When a user defines a VC and attempts to start it, the CLI first tries to transparently discover an active EP by walking through the EPs list specified in its configuration file and testing the EP status. Given that an active EP exists, a GL lookup is sent in order to receive the current GL information. Finally, the request to submit the VC is delegated to the GL which dispatches the VMs on the available GMs. The result is returned to the CLI and presented to the user. Currently, the following information is provided: Assigned VM IP addresses, GM descriptions (i.e. hosts and ports), status (e.g. RUNNING) and an error code which is displayed if problems occurred during the submission. Finally, the GM information on which the VMs were dispatched is stored in the local CLI repository, thus allowing the CLI to directly contact the GM whenever VC/VM management commands need to be performed. The following management commands are currently supported: starting, stopping, suspending, resuming, inter-GM migration, dynamic resizing (number of virtual cores and memory size) as well as retrieving the current live resource usage statistics of the VMs. Finally, it is important to mention that on GM failures the CLI repository information becomes obsolete. When the CLI detects that a GM is not reachable (e.g. during VM resource usage information retrieval) it first queries the EP in order to discover the current GL. Afterwards a GM discovery request including the VM identifier is sent to the GL. Upon reception of the request, the GL queries the currently active GMs in order to find the one assigned to the VM, and returns the result to the CLI. Thus the management command can be performed on the new GM. D. Self-Organization and Self-Healing of the Hierarchy a) GM join process and GL election: When a new GM attempts to join the system, the leader election algorithm is triggered. Currently, our leader election algorithm is built on top of the Apache ZooKeeper [START_REF] Hunt | ZooKeeper: wait-free coordination for internet-scale systems[END_REF] highly available and reliable coordination system, with its implementation following the recipe proposed by the authors of the service in [START_REF]ZooKeeper recipes and solutions[END_REF].

ZooKeeper is integrated as follows. When Snooze is deployed, the ZooKeeper service is installed on the EPs in replication mode. The GM connects to the ZooKeeper service upon boot, creates an ephemeral node in its hierarchical namespace and attaches the GM description (i.e. networking information and an internal Snooze identifier) to it. This node is assigned a unique sequential identifier by the service in the namespace and is used by the GMs in order to discover the current GL and elect a new GL in case of failure. After the node creation each GM first tries to find another node in the namespace with a lower identifier (i.e. predecessor). If such a node already exists, the GM starts watching it and initiates the GL heartbeat multicast listener. Finally, upon reception of a GL heartbeat message, the GM sends a join request along with its description to the GL. Otherwise, if no node with a lower identifier could be detected, the current GM becomes the new GL and starts announcing its presence by sending multicast messages on the GL heartbeat multicast port.

b) GL and GM failure recovery: Each time a failure of a GL or GM occurs, an event is triggered on its successor GM as each node watches its predecessor. The successor GM becomes the new GL if its identifier is the lowest and stops all the GM related logic. Otherwise it simply starts watching the next predecessor GM. When a GM is promoted to be a GL, it gracefully terminates all its tasks such as the heartbeat and monitoring data sender, its open LC connections, and the repository manager. Afterwards the GL logic is started along with the GL heartbeat sender. Finally, as all the existing GMs are still listening for GL heartbeat messages they receive the new GL information and automatically trigger the GL rejoin procedure. Note that in case of a GL failure all its internal knowledge about the existing GMs as well as the distributed VM networking information (i.e. assigned IP addresses) is lost. In order to restore this knowledge, each time a GM rejoins the GL, the GM sends its description along with the VM networking information stored in its repository. Moreover, GM resource utilization summaries are periodically sent back to the GL, thus making it completely recover the system view.

Finally, as a GM has been promoted to become the new GL and thus has terminated all its GM related logic, LCs which were previously assigned to it fail to receive its heartbeat messages and trigger the system rejoin procedure.

c) LC join process and recovery: The join process of a LC works as follows. Each time a LC attempts to join the hierarchy it starts listening for the GL multicast heartbeat messages. When it receives a heartbeat message, the join process is started by sending a GM assignment request with its current description (i.e. host address, port and total capacity) to the GL. The GL then triggers the GM assignment policy and dispatches the LC to an active GM. The contact information of the allocated GM is returned to the LC, which then initiates the actual GM join process by sending its description to the GM. Afterwards, it starts listening for GM heartbeat messages and periodically sends its own heartbeat, host and VM monitoring information to the GM. On an LC failure, the GM gracefully removes it from its database, and adds the IP addresses of the LC's VMs to the list of freed addresses. Note, that in case of LC failure, VMs executing on the LC are terminated. Therefore, snapshot features of hypervisors can be used by LCs in order to periodically save VM states (i.e. CPU, memory, disk) on stable storage on behalf of the GM. This will allow the GM to reschedule the failed VMs on its active LCs.

Finally, in case of a GM failure, the LC rejoins the hierarchy by triggering again the join procedure. Because VM information (i.e. identifier, assigned IP address, etc.) stored by the previous GM might get lost, each time a LC joins the newly assigned GM, it transfers its local state (i.e. information about currently running VMs), thus allowing the GM to update its repository. This update is needed by the clients to discover the new VM location (see Section II-C5) and by the GM to perform VM management operations as well as scheduling decisions.

III. EXPERIMENTAL RESULTS

In order to evaluate the features of the Snooze framework we have deployed it on a 144 nodes cluster of the Grid'5000 experimental testbed in Nancy (France). Each node is equipped with one quad-core Intel Xeon X3440 2.54 GHz CPU, 16 GB of RAM, and a Gigabit Ethernet interconnect. The operating system on each server of the selected cluster is Debian with a 2.6.32-5-amd64 kernel. All tests were run in a homogeneous environment with qemu-kvm 0.14.1 and libvirt 0.9.6-2 installed on all machines. Each VM is using a QCOW2 disk image with the corresponding backing image hosted on a Network File System (NFS). Debian is installed on the backing image and uses a ramdisk in order to speed up the boot process. Finally, the NFS server is running on one of the EPs with its directory being exported to all LCs.

Our study is focused on evaluating the VM submission time in a centralized as well as distributed deployment, the impact of fault tolerance on application performance, and finally the scalability of the framework.

A. Submission time: Centralized vs. Distributed Submission time was evaluated by deploying a large amount of VMs and is defined as the time between initiating the submission request and receiving the reply on the client side. This involves assigning IP addresses, dispatching VMs to the GMs, scheduling VMs on the GMs and finally returning the response to the client.

Two deployment scenarios were created: centralized and distributed. In the former the EP, GL, GM as well as the Apache ZooKeeper service were running on the same machine while 136 nodes were hosting the LCs. This allowed us to reproduce the traditional frontend/backend-model as close as possible. In the latter, the system was configured in a distributed manner with two EPs, each of them hosting a replica of the Apache ZooKeeper service. In addition 6 GMs (including one GL) and 136 LCs were used. Finally, in both scenarios increasing numbers of VMs were submitted simultaneously to the system, the numbers varying from 0 to 500 in 50 VM steps. Each VM required one virtual core and 2 GB of RAM. All VM templates and disk images were pre-created on the NFS-server and submissions happened sequentially directly after the predecessor VMs were terminated. 500 VMs were a good tradeoff (i.e. ∼4 VMs per LC) in order not to risk application performance degradation due to possible resource overcommit.

The experimental results of this evaluation are plotted in Figure 3. As it can be observed, submission time increases approximately linearly with the amount of VMs in both the centralized and distributed deployment. However, more interesting is the fact that besides minor measurement errors, submission times in both scenarios are nearly equivalent thus indicating the good scalability of the system as no overhead of being distributed can be observed. Finally, submission of 500 VMs were finished in less than four minutes which indicates the good quality of our prototype implementation.

B. Impact of Fault-Tolerance on Application Performance

To evaluate the impact of fault tolerance on application performance the system was configured in a distributed manner (see Section III-A). Two types of VMs with the following applications were created: (1) VMs hosting the MPI-implementation of the NAS Parallel Benchmark (NPB) 3.3 [START_REF] Bailey | The NAS parallel benchmarks[END_REF], that represent high performance computing workloads and (2) VMs hosting the Linux, Apache, MySQL, PHP (LAMP) stack running the Pressflow v6 content management system (CMS) [START_REF]Pressflow: Distribution of drupal with integrated performance, scalability, availability, and testing enhancements[END_REF], that represent scalable servers workloads.

For MPI we have selected the FT benchmark from NPB, because of its heavy use of collective communication thus leading to high average network utilization (approximately 100 Mbit/s per VM). The benchmark was run with the Class A problem size across 100 VMs and the total execution time was measured. For web applications, the performance of Pressflow v6 was analyzed while running on a dedicated VM by running the Apache HTTP server benchmarking tool [START_REF]ab -Apache HTTP server benchmarking tool[END_REF] with concurrency set to 100 and number of requests to 1000. All measurements were repeated five times and the average values were taken.

To get an insight in the actual impact of fault tolerance on application performance (i.e. execution time and throughput), system component failures were injected randomly in the middle of the benchmark execution. Three types of failures were injected: single GM failure, catastrophic GM failures (i.e. 1/2 of GMs fail) and finally a GL failure.

The results of this evaluation are shown in Figure 4(a) and 4(b). As it can be observed, apart from measurement errors neither in the MPI nor in the web-based benchmarks any performance degradation can be observed. This is not surprising as the heartbeat overhead is negligible (see Section III-C). Moreover, due to the ZooKeeper service supporting GL election process, the amount of traffic in case of GL failure is low. Indeed, our leader election implementation only requires to watch (i.e. small heartbeat messages) the predecessor nodes (see Section II-D). Similarly, the amount of data required for a GM to rejoin the new GL is approximately 100 bytes (i.e. GM host, port and networking information). Finally, in case of GM failures only small description information (i.e. LC host, port and VM descriptions) needs to be transferred by LCs to the current GL and the new GM thus not requiring substantial amounts of network capacity. Consequently, no overhead of fault tolerance can be observed.

C. Scalability of the Framework

The network load scalability of the framework was evaluated by measuring the network utilization at the GL, GM and LC. From these values we estimated the upper bounds for the network load scalability of the framework. Therefore, to isolate the heartbeat and monitoring traffic the framework was deployed with one EP, GL, GM and LC. Heartbeat intervals of the GL as well as of the GM were set to 3 seconds. Moreover, a fixed-size monitoring information summary was sent by the GM and LC periodically in 10 second intervals. Accounting the monitoring information is important as it is involved in the process of failure-detection (see Section II-D). During all tests, the LC assignment policy as well as the VC and VM scheduling policy were set to round robin thus resulting in a balanced hierarchy in terms of LC assignments as well as VM locations. Figure 5 depicts the correlated incoming and outgoing network traffic of the GL, GM and LC. As it can be observed, the heartbeat multicast messages of the GL only account to approximately 2.5 kB/s thus not putting any significant pressure on the network. On the other hand, GL incoming traffic is mainly dominated by the received GM monitoring summary information which amounts to approximately 4.5 kB/s and is sent using TCP sockets. Given that the summary information is of a fixed size and assumed a gigabit network interconnect, GL could handle approximately up to 140,000 of GMs until its network capacity would become saturated. This theoretical upper bound is much higher than what any existing deployment would need.

0 0.
When considering the network load scalability of the GMs, heartbeats are sent from the each GM to its LCs and vice versa. Analogously to the GL, GM heartbeat messages are multicast based while LC monitoring information is periodically sent using TCP sockets. For scalability and system design reasons, only one TCP connection exists per LC to its assigned GM over which all host, VM and heartbeat monitoring information is sequentially transmitted. Thus when no VMs are active, still a fixed amount of data (i.e. heartbeat) is periodically sent by each LC. This amount of data can be observed in Figure 5. Particularly, as the LC monitoring information is of the same structure as the one from a GM, approximately 4.5 kB/s are arriving at the GM. Similarly, the heartbeat information sent by the GM and GL is equivalent in terms of size (i.e. ∼2.5 kB/s). Putting all these facts together and making the same assumptions about the network bandwidth, similar amount (i.e. ∼140,000) of LCs could be handled by each GM. Finally, when only considering the network load scalability upper bound of the GL as well as of the GMs, theoretically Snooze would be able to manage up to 20 billions of LCs.

We now discuss the CPU and memory load scalability of the GL as well as of the GMs. Figure 6 first presents the GL CPU and memory statistics obtained during the distributed VM submission time evaluation (see paragraph III-A). We notice that there is a short spike in CPU load and memory usage at the beginning of the experiment. Indeed the GL service needs to be started first. Afterwards, the actual VC submission is started. After the boot period the system settles at a fixed memory amount of approximately 327 MB (including OS services) which remains constant with the number of VMs submitted. Similarly, small CPU load spikes can be clearly observed during periods of VM submissions which are as well independent of the VMs amount and never exceed 10% of CPU utilization. Both results emphasize the good scalability of the GL.

In order to get more insights about the GL as well as GM scalability with increasing amount of resources we have evaluated our system with varying numbers of GMs and LCs. In the first experiment, the amount of LCs was fixed and the number of GMs was dynamically doubled every minute until 128 GMs were researched. Same study was conducted with a single GM by increasing the amount of LCs up to 128 and measuring the resulting overheads.

Figure 7 depicts the results from the first evaluation. While the system scales well with respect to CPU utilization (i.e. small spikes during GM joins), because GM summaries are stored in-memory, the memory usage increases linearly with the number of GMs. Note, that this bottleneck can be resolved by providing a different implementation for the repository interface (e.g. based on Apache Cassandra [START_REF] Lakshman | Cassandra: structured storage system on a P2P network[END_REF]).

Figure 8 presents the results from the second experiment. Apart from a similar repository bottleneck, the system shows good CPU load scalability with increasing number of LCs. Several open-source as well as proprietary VM management frameworks such as OpenNebula [START_REF] Milojicic | OpenNebula: A cloud management tool[END_REF], Nimbus [START_REF] Keahey | Virtual workspaces for scientific applications[END_REF], OpenStack [START_REF]OpenStack: Open source cloud computing software[END_REF], VMware Distributed Resource Scheduler (DRS) [START_REF] Vmware | Distributed Resource Scheduler (DRS)[END_REF], and Eucalyptus [START_REF] Nurmi | The Eucalyptus open-source cloud-computing system[END_REF] have been developed during the last years. Thereby, the architectures of the first four frameworks follow the traditional frontend/backend model and thus suffer from limited scalability and SPOF.

Eucalyptus is the closest open-source system in terms of architecture. Similar to the architecture of Snooze, a higher instance (i.e. cloud controller) oversees the underlying cluster controllers. The cluster controllers on the other hand are in charge of managing the compute resources each running a node controller. However, unlike in Snooze where a group manager is designed to manage a subset of each cluster, each cluster controller in Eucalyptus is designed to manage the entire cluster thus making it suffer from SPOF. Moreover, Eucalyptus does not include any self-healing features and strictly distinguishes between cloud and cluster controllers (i.e. static hierarchy) while Snooze follows a more selforganizing approach in which each group manager (GM) is promoted to a group leader (GL) dynamically during the leader election procedure and upon GL failure detection. In addition, cluster controllers of Eucalyptus do not support VM resource (i.e. CPU utilization, memory and network) monitoring. Thus they are limited to simple static VM scheduling policies (e.g. greedy, round robin). On the contrary, in Snooze each GM is designed to periodically receive VM resource usage information from the local controllers (LCs).

Recently in [START_REF] Cornabas | A distributed and collaborative dynamic load balancer for virtual machine[END_REF] a more distributed peer-to-peer (P2P) based VM scheduling approach is introduced. However, this work is still in very early stages as it is limited to a single load balancing policy and no evaluation regarding its scalability and fault tolerance aspects is performed. Finally, only limited simulation-based results are presented. Another VM management framework based on a P2P network of nodes is presented in [START_REF] Quesnel | Cooperative dynamic scheduling of virtual machines in distributed systems[END_REF]. The nodes are organized in a ring and scheduling is performed iteratively upon underload and overload events triggered by the nodes. However, neither the overhead of maintaining the ring structure nor the scalability and fault tolerance aspects are discussed. Similarly to the previous work only preliminary simulation-based results targeting the scheduling time are presented. In contrast to these two works, nodes in Snooze are dynamically organized in a self-healing hierarchical architecture. This allows it to scale with the increasing number of nodes (i.e. GL does not require global knowledge) as well as to provide the required fault tolerance properties without the need to rely on P2P technology. In fact, our experimental results show that a lightweight approach taken in our work is sufficient in order to provide scalability and fault tolerance properties for data center sizes which go beyond existing deployments. Moreover, Snooze is a working implementation which provides most of the features (i.e. client interface, support for different scheduling policies, virtual network management, etc) required for it to be called a management framework. Last but not least, it is evaluated in a real environment and shown to be scalable and fault-tolerant. Still, it is clear that the scalability of our system is bounded by its GL which acts as a fault-tolerant lightweight central point. Despite the fact that GL can be replicated and a load balancing layer can be added to improve its scalability, when developed and evaluated, fully decentralized P2P-based systems could turn out to be even more scalable alternatives.

Besides the existing VM management frameworks, more generic frameworks targeting scalability and fault tolerance issues in distributed systems have been proposed in the past. Particularly, the hierarchical layer of Snooze is inspired from the idea introduced in the Hasthi [START_REF] Perera | Enforcing user-defined management logic in large scale systems[END_REF] framework which takes a hierarchical self-stabilizing approach for managing large-scale distributed systems. Through simulations the authors show that their system is able to scale up to 100,000 resources. Contrary to Hasthi whose design is presented to be system agnostic and utilizes a distributed hash table (DHT) based peer-to-peer (P2P) network, Snooze follows a simpler design and does not require the use of P2P technology. Moreover, it targets virtualized platforms and thus its design and implementation is driven by the platform specific objectives and issues. Finally, Snooze has a working implementation which is evaluated in a real environment. Similarly to Hasthi our system is shown to achieve excellent scalability.

Another system based on a hierarchical architecture is called DIET [START_REF] Caron | DIET: A scalable toolbox to build network enabled servers on the grid[END_REF]. However, DIET implements the GridRPC programming model while Snooze targets VM management. Consequently, both frameworks are orthogonal. For example, virtual resources of Snooze can be used by the DIET framework in order to perform computation tasks.

V. CONCLUSIONS AND FUTURE WORK

In this paper, we have presented a novel scalable and fault-tolerant VM management framework called Snooze. Unlike the previous open-source virtual infrastructure managers, Snooze employs a self-organizing hierarchy in which the VM management tasks are distributed across multiple selfhealing group managers (GMs) with each GM having only a partial view of the system. Thereby, each GM is only in charge of managing a subset of the compute nodes (i.e. local controllers (LCs)). Moreover, a group leader (GL) dispatches VM submission requests and handles the VM networking. This allows our framework to stay highly scalable as the GL does not require any global system knowledge. In addition, the GL facilitates the system management by playing the role of a fault-tolerant coordinator. Such a coordination helps keeping the design and implementation simple. Finally, to the best of our knowledge this is the first work to analyze the load scalability and fault tolerance of an IaaS-cloud computing framework in a real environment.

Our extensive evaluation conducted on the Grid'5000 experimental testbed has shown that: (1) submission time is not impacted by performing distributed VM management, (2) systems fault tolerance properties do not impact application performance and finally (3) the system scales well with increasing number of resources thus making it suitable for managing large-scale virtualized data centers. Finally, thanks to the integrated VM monitoring and resource demand estimation support as well as the generic scheduling engine, the system is well suitable as a research testbed to design, implement and evaluate advanced VM placement policies in a real environment.

In the future, we plan to conduct a performance comparison of Snooze with existing open-source cloud management frameworks. Recent evaluating efforts (e.g. [START_REF] Sotomayor | Virtual infrastructure management in private and hybrid clouds[END_REF], [START_REF] Sempolinski | A comparison and critique of Eucalyptus, OpenNebula and Nimbus[END_REF]) mainly focus on the functional aspects. Moreover, the system will be made even more autonomic by removing the distinction between GMs and LCs. Consequently, the decisions when a node should play the role of GM or LC in the hierarchy will be taken by the framework instead of the system administrator upon configuration. In addition, we will improve the scalability of the database and GL. Particularly, current in-memory repository implementation will be replaced by a distributed NoSQL database (i.e. Apache Cassandra). Scalability of the GL will be improved by adding replication and additional load balancing layer. Finally, the NFS-based VM image storage will be replaced by a distributed file system (e.g. BlobSeer [START_REF] Nicolae | BlobSeer: Next-generation data management for large scale infrastructures[END_REF]).

Another important aspect of our work is power management. Snooze already has experimental support for power management and VM consolidation which will be evaluated along with the integration of our recently proposed natureinspired VM placement algorithm [START_REF] Feller | Energy-aware ant colony based workload placement in clouds[END_REF] in the near future. Ultimately, Snooze will become an open-source project.

Fig. 3 .

 3 Fig. 3. Submission time: Centralized vs. Distributed

Fig. 4 .

 4 Fig. 4. Impact of fault tolerance on application performance

Fig. 5 .

 5 Fig. 5. Network load scalability

Fig. 6 .

 6 Fig. 6. GL CPU and memory during VM submission

Fig. 7 .

 7 Fig. 7. GL CPU and memory during VM submission

Fig. 8 .

 8 Fig. 8. GM CPU and memory with increasing amount of LCs

  At the physical layer, the LC of a node is in charge of the following tasks: (1) joining the hierarchy during system boot and rejoining the hierarchy

		Client	Client		Client
	Client layer	C Binding	Client Interface C++ Binding	Java Binding
		Entry Point	Entry Point	Entry Point
	Hierarchical layer	Group Manager	Group Manager Group Leader	Group Manager
		Local Controller		Local Controller
		Monitor Actuator		Monitor	Actuator
	Physical layer	Virtualization Management Library Common Cluster Monitoring and Management Interface
		Virtualized Node		Virtualized Node
			Cluster
		Fig. 1. Global system overview
	in case of GM failures; (2) performing total host capacity
	retrieval (total amount of CPUs/cores, memory and network
	capacity); (3) performing VM monitoring (current CPU, mem-
	ory, and network utilization); (4) enforcing VM management
	commands (start, suspend, resume, save, restore, shutdown,
	destroy, resize and migrate).

1) Local Controller (LC):

VI. ACKNOWLEDGMENTS

We wish to express our gratitude to Stefania Costache, Piyush Harsh, and Pierre Riteau for their detailed feedback. This research is funded by the French Agence Nationale de la Recherche (ANR) project EcoGrappe under the contract number ANR-08-SEGI-000. Experiments presented in this paper were carried out using the Grid'5000 experimental testbed, being developed under the INRIA ALADDIN development action with support from CNRS, RENATER and several Universities as well as other funding bodies (see https://www.grid5000.fr).