Decentralized On-line Task Reallocation on Parallel Computing Architectures with Safety-Critical Applications

This work presents a decentralized allocation algorithm of safety-critical application on parallel computing architectures, where individual Computational Units can be affected by faults. The described method consists in representing the architecture by an abstract graph where each node represents a Computational Unit. Applications are also represented by the graph of Computational Units they require for execution. The problem is then to decide how to allocate Computational Units to applications to guarantee execution of the safety-critical application. The problem is formulated as an optimization problem, with the form of an Integer Linear Program. A state-of-the-art solver is then used to solve the problem. Decentralizing the allocation process is achieved through redundancy of the allocator executed on the architecture. No centralized element decides on the allocation of the entire architecture, thus improving the reliability of the system. Experimental reproduction of a multi-core architecture is also presented. It is used to demonstrate the capabilities of the proposed allocation process to maintain the operation of a physical system in a decentralized way while individual component fails.

💡 Research Summary

The paper addresses the challenge of maintaining safety‑critical applications on parallel computing platforms—such as multi‑core processors, clusters, or fleets of robots—when individual computational units (CUs) suffer faults. The authors model the hardware as a directed simple graph G(V,E) where vertices represent CUs and edges represent bidirectional communication links. Each application is also represented as an undirected graph G_k(V_k,E_k), with nodes denoting sub‑tasks and edges denoting required inter‑task communication.

The core contribution is a formulation of the allocation and reallocation problem as an Integer Linear Program (ILP). Decision variables include a binary matrix X_CU→node mapping tasks to CUs, a binary matrix X_path→link mapping application links to physical links, a binary vector r indicating which applications remain active, a binary vector M marking tasks that have been moved, and a set of matrices X_Comm,k (with entries –1, 0, +1) describing the communication paths used by each allocator replica.

The objective function is hierarchical: first, it maximizes the weighted sum of running applications according to their priority; second, it penalizes any task reallocation; third, it minimizes the total length of communication paths used by the allocator replicas. Large coefficients (α_k, β) are carefully chosen so that higher‑priority applications dominate lower‑priority ones, and reallocation costs dominate communication costs.

Constraints enforce (a) binary domains for most variables, (b) exclusive assignment of each CU to at most one task, (c) correct mapping of application links onto physical links, (d) exclusion of faulty CUs from the allocation pool, and (e) consistency of communication‑path variables. The model is re‑solved each time a fault is detected.

To achieve decentralization, the allocator itself is replicated N_realloc times and executed on the platform. Each replica independently solves the ILP; the final allocation is decided by majority voting among the replicas, eliminating a single point of failure.

The authors validate the approach on a prototype built from sixteen Raspberry Pi single‑board computers, each acting as a CU. They inject faults by disabling individual Pis and observe that the remaining allocator replicas quickly recompute a feasible allocation, keeping the safety‑critical application running while lower‑priority applications may be dropped. Measurements show reduced recovery time and higher overall system availability compared with a centralized allocator.

In summary, the paper presents a rigorous graph‑based ILP model for fault‑aware task allocation, augments it with a novel decentralized voting mechanism, and demonstrates its practicality on a realistic multi‑node testbed. The work contributes a scalable, fault‑tolerant methodology that can be applied to aerospace, automotive, and other safety‑critical domains where parallel processing and high reliability are required.