Skip to Main Content
In this paper, we present an adaptive, bandwidth-based group scheduling mechanism that supports reconfiguration of components in compositional software architectures. The middleware-level scheduler allocates resources accurately for real-time threads while non-real-time threads are dealt with in a manner that makes the most of the remaining bandwidth within a thread group. We have designed and implemented the thread-group scheduler in the context of a middleware for embedded real-time control systems, where mixed-criticality tasks may co-exist on the same platform and temporal firewall is of immense value. Yet, it is often the case that better resource-management, flexibility and efficiency are rewarded a great deal due to the high cost of development and the bespoke nature of control systems. With the increasing complexity of large software systems, it is often difficult to reason about how architectural or compositional artefacts are to be linked with non-functional attributes, especially when it comes to scheduling of threads in reconfigurable component-based systems. In other words, there is no clean-cut binding between components and tasks or threads in terms of resource allocation and quality of service provision. For instance, when a component with a varying number of threads inside is to be replaced, it becomes challenging to allocate resources fairly and accurately due to the changing requirements (or number of threads) in the new component in terms of the required CPU time before and after the reconfiguration. The recent temporal firewall approach in the literature works well on a per-thread basis resource allocation, but when the knowledge of threads and the timing requirements are unknown at pre-runtime due to the possible replacement of components with a varying number of subordinate threads, it is impossible to allocate resources effectively. This work builds on the temporal firewall approach to cater for compositional software systems.