Joel Nider

Cross-ISA Container Migration

Containers are a convenient way of encapsulating and isolating applications. They incur less overhead than virtual machines and provide more flexibility and versatility to improve server utilization. Many new cloud applications are being written in the microservices style to take advantage of container technologies. Each component of the application can be encapsulated in a separate container, which enables the use of other features such as auto-scaling. However, legacy applications can also benefit from containers which provide more efficient development and deployment models. In modern data centers, orchestration middle-ware is responsible for container placement, SLA enforcement and resource management. The orchestration software can implement various policies for managing the resources. The orchestration software can take corrective actions when detecting inefficiencies in the data center operation to satisfy the current policy. Power efficiency is becoming one of the most important characteristics taken into account when designing a data center and defining policy for the orchestration middleware [4]. Different server architectures have different power efficiency and energy proportionality characteristics. Recent research has shown that heterogeneous systems have the potential to significantly improve energy efficiency[3, 5]. Our work focuses on the mechanism required by the middle-ware to implement a power optimization policy. We research migration of containerized applications between servers inside a heterogeneous data center, for the purpose of optimizing power efficiency. Migrating a running container between different architectures relies on the compatibility of the application environment on the source and destination servers. Containers are viewed as a set of one or more processes and each process must have the ability to be migrated. A modified compiler is used to build executables in a manner allowing the program migration between different architectures. The source and destination servers must also have a shared file system and comparable networking capabilities. We take advantage of the recently added user-space page fault feature in the Linux kernel [2] to implement post-copy container migration in CRIU [1]. Post-copy migration significantly reduces perceived down-time of the container, and can potentially reduce network traffic as well. We propose creating a cluster of servers with different architectures (i.e., ARM, POWER, and x86) connected with a high-speed, low-latency network. This cluster will run SaaS applications in a containerized environment. The applications will be built using a specialized toolchain that ensures an identical memory layout across all architectures, enabling seamless migration at runtime. The majority of the challenges in cross-ISA migration are related to the toolchain adaptation, and ensuring the compatibility of the runtime environment across various servers in the cluster. The ability to efficiently migrate running containers between servers with different energy proportionality characteristics provides improved power savings during idle periods without compromising SLA commitments.

High performance fault-tolerance for clouds

Cloud computing and virtualized infrastructures are currently the baseline environments for the provision of services in different application domains. While the number of service consumers increasingly grows, service providers aim at exploiting infrastructures that enable non-disruptive service provisioning, thus minimizing or even eliminating downtime. Nonetheless, to achieve the latter current approaches are either application-specific or cost inefficient, requiring the use of dedicated hardware. In this paper we present the reference architecture of a fault-tolerance scheme, which not only enhances cloud environments with the aforementioned capabilities but also achieves high-performance as required by mission critical every day applications. To realize the proposed approach, a new paradigm for memory and I/O externalization and consolidation is introduced, while current implementation references are also provided.

Zero-Copy Receive for Virtualized Network Devices

When receiving network traffic on guest VMs (virtual machines) running on the KVM hypervisor, data is copied from hypervisor buffers to guest buffers. This copy incurs CPU and latency overhead. It seems desirable to avoid this copy, if possible, and to use guest buffers directly to receive network data. A number of challenges must be overcome in order to accomplish this zero-copy receive, and some additional overhead is incurred in setting it up. We present the technical details on a zero-copy receive design and implementation and discuss the resulting performance degradation. In our implementation, the savings in CPU from avoiding the copy is overshadowed by the extra handling required for the smaller and often underutilized buffers .

User space memory management for post-copy migration

Post-copy migration allows reduction of application down-time and reduces overall network bandwidth used for application migration [4]. Migration can be used to help optimize several aspects of operations such as power efficiency[3]. The userfault technology recently introduced to the Linux kernel allows post-copy migration of virtual machines. However, this technology is missing essential features required for post-copy migration of Linux containers.

Remote page faults with a CAPI based FPGA

Post-copy VM or container migration requires that the bulk of the memory is transferred after resuming on the destination node [3]. Transferring memory between nodes over a commodity TCP/IP network incurs too much latency, which slows down execution of the application on the destination node.

Zero-copy receive path in virtio

In the KVM hypervisor, incoming packets from the network must pass through several objects in the Linux kernel before being delivered to the guest VM. Currently, both the hypervisor and the guest keep their own sets of buffers on the receive path. For large packets, the overall processing time is dominated by the copying of data from hypervisor buffers to guest buffers.

Workload Management for Power Efficiency in Heterogeneous Data Centers

The cloud computing paradigm has recently emerged as a convenient solution for running different workloads on highly parallel and scalable infrastructures. One major appeal of cloud computing is its capability of abstracting hardware resources and making them easy to use. Conversely, one of the major challenges for cloud providers is the energy efficiency improvement of their infrastructures. Aimed at overcoming this challenge, heterogeneous architectures have started to become part of the standard equipment used in data centers. Despite this effort, heterogeneous systems remain difficult to program and manage, while their effectiveness has been proven only in the HPC domain. Cloud workloads are different in nature and a way to exploit heterogeneity effectively is still lacking. This paper takes a first step towards an effective use of heterogeneous architectures in cloud infrastructures. It presents an in-depth analysis of cloud workloads, highlighting where energy efficiency can be obtained. The microservices paradigm is then presented as a way of intelligently partitioning applications in such a way that different components can take advantage of the heterogeneous hardware, thus providing energy efficiency. Finally, the integration of microservices and heterogeneous architectures, as well as the challenge of managing legacy applications, is presented in the context of the OPERA project.

IO Core Manager for Virtual Environments

Para-virtualization is the leading approach in IO device virtualization. It allows the hypervisor to interpose on and inspect a virtual machines I/O traffic at run-time. Examples of such interfaces are KVMs virtio [6] and VMWares VMXNET [7]. Current implementations of virtual I/O in the hypervisor have been shown to have performance and scalability limitations [2, 3, 5]. The overhead incurred during interposition arises from two main sources: VM exits and thread scheduling. VM exits are caused when the virtual machine requires some intervention of the hypervisor in order to continue execution. VM exits are required to perform I/O tasks since the VM does not have direct access to I/O hardware [1]. The second source of overhead is the hypervisors thread scheduler, which is not aware of the type of work being performed by a particular thread. When executing I/O threads have work (i.e. I/O traffic to process), the scheduler schedules the thread without regard to the latency or throughput requirements of the virtual device. In workloads with a small amount of latency-sensitive traffic, the thread context switches can become prohibitively costly. The limitations can be somewhat mitigated by using the side-core [4] approach, which divides the system cores into two distinct sets: one for running VM guests, and the other dedicated to virtual I/O processing. However, the number of cores that should be assigned to each set is dependent on the constantly changing workload. For optimum performance, the resources must be allocated according to measurements taken at runtime. We present IOcm which is able to tune the system automatically for using the side-core approach. IOcm provides a better foundation for building practical systems using the side-core approach by improving its usability. IOcm includes mechanisms that expose statistics and controls that allow for better management of the system. We show that IOcm is able to provide comparable performance to a side-core system tuned by an oracle.