Currently, there is a strong push towards real-time support distributed over large geographical areas, fuelled by emerging applications as interactive multimedia, remote interactions, cloud-based time-sensitive services and many cyber-physical systems [1]. These applications have a distinctive property that they rely on many different resources, from the end nodes where they execute, to the networks over which they communicate. However, supporting these applications in a way that is globally composable, in the sense that their performance can be guaranteed a priori and will not be affected by load variations in the global system, is a significant challenge. It calls upon resource reservations across the system that comply to performance metrics agreed at the time of application deployment, what is normally called Service Level Agreement (SLA). This means the application resource requirements must be well defined, from the computing end nodes, possibly including multiple internal resources, to the network.
In spite of existing technical solutions for enforcing reservations, for example, virtualization approaches in processors, and tunneling in networks, such solutions typically fall short on at least two aspects, scalability and adaptability. The former is needed to cope with large numbers of reservations to achieve the desired segregation and isolation among applications, while the latter is needed to mitigate the effects of overprovisioning that micro-reservations can have in the efficiency of the whole system. These two requirements apply particularly to the network, given its central position in supporting the applications referred above and, in general, emerging paradigms such as the Internet-of-Things. Nevertheless, adaptability naturally extends from the network to the ends nodes, for the sake of efficiency, too.
On the other hand, the scalable solutions that we have today, which are, for example, deployed in current Internet, provide at best class-based Quality-of-Service (QoS) support [2]. Thus, similar applications are aggregated in classes and protected against interference from traffic of lower QoS that is delay tolerant. However, there is still the potential for mutual interference inside the same class, which can become problematic as the number of such applications grows, e.g. VoIP calls.
Borrowing terminology and concepts from networking, we can say that we need to resort to circuit switching at a fine scale. Circuits establish channels with guaranteed resource capacity that support deterministic applications execution. However, as known since the advent of packet switching, circuit switching is not efficient given the micro-partitioning of the resources that continue allocated independently of their effective usage. This is where adaptability enters, making channels adaptive so that their resources can be released whenever their actual usage is below their assigned capacity but this capacity needs to be quickly recovered in case it becomes needed again. Such a scheme requires that other applications in the system can in turn take advantage of the extra resources that are made temporarily available.
A consequence of scalability is that the resource management needed by such adaptive schemes must be distributed. However, experience with flexible resource reservations has shown that effective and efficient management requires some level of centralization of resource usage to avoid the delays that distributed agreement approaches would incur. The obvious solution is to combine local centralization with global distribution, for example, using clustering. Local reservations are then managed at the cluster level and end-to-end reservations require a distributed cluster-level protocol. This is, again, the technique followed by existing distributed reservation approaches such as SRP in Audio-Video Bridges, which however, are class-oriented.

Therefore, given the considerations above, we herein formulate what we consider to be open problems to achieve the desired compositionality of distributed real-time applications in large open systems, in a resource efficient way.
Given a distributed real-time application that will execute in N end nodes connected to a large network, then how to:
- Formulate its resource requirements and define adequate interfaces?
- Express adaptivity in such requirements/ interfaces?
- Support scalable reservations in the network, and particularly in an adaptive way that still guarantees the reservations?
- Analyze whether the requirements can be met, per resource and in whole?
- Carry out global admission control and enforce the needed reservations?
- Measure actual