PhD Thesis Topic: Optimisations for microservice-based modular systems

Modern cloud-based applications are designed in a highly modular way, as a network of abstract components (micro-services, actors, containers, processes, lambdas, etc.) that are virtualised, weakly coupled and communicate only by messaging.

Designing a complex system by composing relatively simple individual components is a win from a software engineering perspective. However, from a systems perspective, it comes with a high price in performance and control. Message-based communication through layers of abstraction is costly. A virtualised abstraction uses actual resources but their mapping is opaque. Deploying, managing, controlling and debugging the network of actors is challenging. Interactions between components are complex, and the overall behaviour of the system is hard to understand. Higher-level abstractions can help to alleviate this complexity; however, abstraction boundaries are typically opaque and have a high run-time cost.

Research questions

The Delys research group has an interest in designing distributed systems by composition, addressing the issues of complexity, correctness and performance. Within this context, this PhD proposal focuses on reconciling abstraction with performance and control. We note that there are a number of common, high-level patterns to mapping an abstraction to resources for performance, which we might call meta-optimisations:

• Elasticity: As demand for a service increases or decreases, spawn or kill replicas of the corresponding component(s), thus increasing or decreasing the usage of physical resources.

• Placement (location control): As remote communication is costly, co-locate a service with its clients, or, more generally, co-locate components that communicate strongly, and co-locate a computation with its CPU, storage and network resources. Conversely, fault tolerance requires that replicas of a service execute on different hardware in order to decouple their failure modes (anti-co-location).

• Resource consolidation vs isolation. Components that are co-located can improve efficiency by to sharing local physical resources, such as CPU, memory, GPU, disk, etc. Examples include communicating via shared memory, or multiplexing multiple journals into a single file. On the flip side, there is the need for isolation between components competing for a resource, which requires some form of arbitration.

• Merging. Different components that are co-located on the same processor remain logically distinct, yet can be merged into a single unit, in order to remove the abstraction overheads. For instance, two separate actor instances might be compiled into a single process.

• Sharing virtualised resources. Even when not co-located, components can share a virtualised resource, e.g., shared memory or database. As this creates an indirect coupling between actors, an appropriate consistency model is required.

These meta-optimisations are already known, but they have been studied in isolation, and are often ad-hoc, manual or awkwardly outside of the main programming model, e.g., in deployment tools (e.g., Kubernetes or Docker Swarm), or higher-level language tools (e.g., partial evaluation).

Research objectives

The PhD student will perform a study of meta-optimisations (the above and any others of interest). He/she will aim to elucidate the underlying principles, to formalise them, to identify their primitive mechanisms, and to make them easily accessible, in a consistent manner, via language and/or system support.

For instance, placement is an important driver of performance; to manage placement, the developer must be able to address a resource as a first-class entity of the programming environment. The system should provide primitives for co-locating (resp. anti-co-locating) a component with a resource or with another component. It should be possible to compile away the performance bottlenecks between co-located actors (e.g., using partial evaluation), while maintaining sufficient isolation between them.

Note how these meta-optimisations break abstraction boundaries (for instance, to co-locate components from different subsystems that access a same resource, or to merge together logically separate components).

The service objectives of meta-optimisations are often in conflict. Therefore, a large part of the PhD will be studying and controlling the trade-offs between them.

How to apply

The PhD candidate must:

• Acquire a Masters degree in Computer Science / Informatics or a related field by the start of the PhD.

• Have an excellent academic record.

• Be highly motivated by systems and/or language research in modern, complex distributed systems, algorithms or applications, and have a good knowledge in the subject.

• Be motivated by combining fundamental with experimental research.

The PhD will take place in the Delys group, at Laboratoire d’Informatique de Paris-6 (LIP6), in Paris. It will be advised by Dr. Mesaac Makpangou and supervised by Prof. Julien Sopena and Dr. Marc Shapiro. To apply, contact the supervisors with the following information:

• A resume or Curriculum Vitæ.

• A list of courses and grades of the last two years of study (an informal transcript is OK).

• Names and contact details of two references (people who can recommend you), whom we will contact directly.