Channel extrapolation is a promising technique to estimate the Channel State Information (CSI) in multi-input-multi-output (MIMO) systems operating in frequency division duplex (FDD) without relying on costly terminal feedback. In this paper we analyze the limits that can achieve the extrapolation of the frequency response of a propagation channel from its cluster-based representation. This method consists in measuring all the clusters characteristics (angle of departure, gain, delay) on the uplink and then extrapolating the downlink channel from those measurements. We propose a framework in which the limits of a cluster-based extrapolation process are studied taking into account delay and angular spread derived from the Saleh-Valenzuela model. We evaluate the performance of the optimal linear estimator hereby quantifying the extrapolation residual error bound in terms of Mean-Square Error and Reduction of the Beamforming Gain.

In this paper we analyze the number of degrees of freedom needed to accurately capture and model wideband MIMO-OFDM channels. Two modeling approaches are considered, either examining each coefficient of the conventional input-output MIMO channel matrix or investigating the components constituting the physical ray-based propagation between the antenna arrays. As our analysis accounts for wideband channels, a time domain decomposition of MIMO channels into tapped delay lines is performed in each case. The efficiency of each approach is then evaluated in terms of number of taps to determine the most appropriate representation between either the conventional antenna-based one or the propagation-based one. This analysis is performed analytically using the Saleh-Valenzuela model which is recognized for its consistency for wideband as well as spatial modeling. We exploit the second-order statistics of the Channel Impulse Response to derive the taps weights.

More than two decades ago, combinatorial topology was shown to be useful for analyzing distributed fault-tolerant algorithms in shared memory systems and in message passing systems. In this work, we show that combinatorial topology can also be useful for analyzing distributed algorithms in networks of arbitrary structure. To illustrate this, we analyze consensus, set-agreement, and approximate agreement in networks, and derive lower bounds for these problems under classical computational settings, such as the LOCAL model and dynamic networks.

In a multiple-input-multiple-output (MIMO) communication system, the multipath fading tends to vanish with increasing number of radio links. This well-known channel hardening phenomenon plays a central role in the design of massive MIMO systems. It is quantified by the coefficient of variation of the channel gain. The aim of this paper is to study channel hardening using a physical channel model in which the influences of propagation rays and antenna array topologies are highlighted. Our analyses and closed form results extend the hardening properties beyond the classical Rayleigh fading models and offer further insights on the relationship with channel characteristics.

Abstract Computer‐based systems are now expected to evolve during their service life to cope with changes of various nature, ranging from evolution of user needs, eg, additional features requested by users, to system configuration changes, eg, modifications in available hardware resources. When considering resilient embedded systems that must comply with stringent dependability requirements, the challenge is even greater, as evolution must not impair dependability attributes. Maintaining dependability properties when facing changes is, indeed, the exact definition of resilient computing. In this paper, we consider the evolution of systems with respect to their dependability mechanisms and show how such mechanisms can evolve with the system evolution, in the case of ROS, the robot operating system. We provide a synthesis of the concepts required for resilient computing using a component‐based approach. We particularly emphasize the process and the techniques needed to implement an adaptation layer for fault tolerance mechanisms. In the light of this analysis, we address the implementation of adaptive fault tolerance on ROS in 2 steps: Firstly, we provide an architecture to implement fault tolerance mechanisms in ROS, and secondly, we describe the actual adaptation of fault tolerance mechanisms in ROS. Beyond the implementation details given in the paper, we draw the lessons learned from this work and discuss the limits of this run‐time support to implement adaptive fault tolerance features in embedded systems.

In real-time mixed-critical systems, Worst-Case Execution Time (WCET) analysis is required to guarantee that timing constraints are respected—at least for high-criticality tasks. However, the WCET is pessimistic compared to the real execution time, especially for multicore platforms. As WCET computation considers the worst-case scenario, it means that whenever a high-criticality task accesses a shared resource in multicore platforms, it is considered that all cores use the same resource concurrently. This pessimism in WCET computation leads to a dramatic underutilization of the platform resources, or even failing to meet the timing constraints. In order to increase resource utilization while guaranteeing real-time guarantees for high-criticality tasks, previous works proposed a runtime control system to monitor and decide when the interferences from low-criticality tasks cannot be further tolerated. However, in the initial approaches, the points where the controller is executed were statically predefined. In this work, we propose a dynamic runtime control which adapts its observations to online temporal properties, further increasing the dynamism of the approach, and mitigating the unnecessary overhead implied by existing static approaches. Our dynamic adaptive approach allows one to control the ongoing execution of tasks based on runtime information, and further increases the gains in terms of resource utilization compared with static approaches.

Safety-critical systems with decisional abilities, such as autonomous robots, are about to enter our everyday life. Nevertheless, confidence in their behavior is still limited, particularly regarding safety. Considering the variety of hazards that can affect these systems, many techniques might be used to increase their safety. Among them, active safety monitors are a means to maintain the system safety in spite of faults or adverse situations. The specification of the safety rules implemented in such devices is of crucial importance, but has been hardly explored so far. In this paper, we propose a complete framework for the generation of these safety rules based on the concept of safety margin. The approach starts from a hazard analysis, and uses formal verification techniques to automatically synthesize the safety rules. It has been successfully applied to an industrial use case, a mobile manipulator robot for co-working.

Event logging is a key source of information on a system state. Reading logs provides insights on its activity, assess its correct state and allows to diagnose problems. However, reading does not scale: with the number of machines increasingly rising, and the complexification of systems, the task of auditing systems' health based on logfiles is becoming overwhelming for system administrators. This observation led to many proposals automating the processing of logs. However, most of these proposal still require some human intervention, for instance by tagging logs, parsing the source files generating the logs, etc. In this work, we target minimal human intervention for logfile processing and propose a new approach that considers logs as regular text (as opposed to related works that seek to exploit at best the little structure imposed by log formatting). This approach allows to leverage modern techniques from natural language processing. More specifically, we first apply a word embedding technique based on Google's word2vec algorithm: logfiles' words are mapped to a high dimensional metric space, that we then exploit as a feature space using standard classifiers. The resulting pipeline is very generic, computationally efficient, and requires very little intervention. We validate our approach by seeking stress patterns on an experimental platform. Results show a strong predictive performance (≈ 90% accuracy) using three out-of-the-box classifiers.

Recent studies have introduced co-location attacks as a powerful way to extract social information from location traces. However, these attacks all rely by some means on the position of targeted users. This requires the attacker to be able to locate either the user or the sensors detecting the user. Implicitly, it also forbids the use of these attacks on devices whose location is unknown.

Adaptive renaming can be viewed as a coordination task involving a set of asynchronous agents, each aiming at grabbing a single resource out of a set of resources totally ordered by their desirability. We consider a generalization of adaptive renaming to take into account scenarios in which resources are not independent.

Although multi/many-core platforms enable the parallel execution of tasks, the sharing of resources may lead to long WCETs that fail to meet the real-time constraints of the system. Then, a safe solution is the execution of the most critical tasks in isolation followed by the execution of the remaining tasks. To improve the system performance, we propose an approach where a critical task can run in parallel with less critical tasks, as long as the real-time constraints are met. When no further interferences can be tolerated, the proposed run-time control suspends the low critical tasks until the termination of the critical task. In this paper, we describe the design and prove the correctness of our approach. To do so, a graph grammar is defined to formally model the critical task as a set of control flow graphs on which a safe partial WCET analysis is applied and used at run-time to control the safe execution of the critical task.

This paper presents a methodology to guide the evaluation of social distributed applications in mobile environments. Even when applications are already designed, they exhibit a number of tuning parameters upon which network operators can act in order to improve performance. Accordingly, evaluation can be a valuable tool to determine for a particular mobile application which is the most suitable parameters setup from a performance point of view. Our methodology can be of great interest in this tuning process, thus saving both time and money. The main novelty of this methodology is the use of diversification to recreate mobile environments using both synthetic and real mobility traces. Our work focuses on how micro-mobility may impact social distributed applications. The feasibility of the paper is showed through a realistic microblogging case study.

Automotive embedded systems are becoming increasingly complex. Therefore verification activities are paramount to ensure safety. ISO 26262 is the first standard specifically dedicated to automotive safety systems. This standard requires introducing fault injection (FI) from the very early phases of the development process. Our work aims at developing an approach that will help integrate FI in the whole development process in a continuous way, from system requirements to the verification and validation phase. In this paper, we concentrate on exploring the benefits of safety analyses for experimental validation of the system. We propose an analogy between FI during the pre-implementation phase with safety analyses that are of common use during system design. We finally illustrate this approach on a case study from the automotive domain.

A secure location-based service requires that a mobile user certifies his position before gaining access to a resource. Currently, most of the existing solutions addressing this issue assume a trusted third party that can vouch for the position claimed by a user. However, as computation and communication capacities become ubiquitous with the large scale adoption of smartphones by individuals, we propose to leverage on these resources to solve this issue in a collaborative and private manner. More precisely, we introduce PROPS, for PRivacy-preserving lOcation Proof System, which allows users to generate proofs of location in a private and distributed way using neighboring nodes as witnesses. PROPS provides security properties such as unforgeability and non-transferability of the proofs, as well as resistance to classical localization attacks.

Simulating human-centered pervasive systems requires accurate assumptions on the behavior of human groups. Recent models consider this behavior as a combination of both social and spatial factors. Yet, establishing accurate traces of human groups is difficult: current techniques capture either positions, or contacts, with a limited accuracy.

Assessing the correct behavior of a given system at run-time can be achieved by monitoring its execution, and is complementary to off-line analysis such as static verification. In this work, we focus on run-time monitoring of system properties that include both causality and timing constraints, in distributed and time-constrained systems. Based on a description of a property that includes events and temporal constraints, expressed as a timed-arc Petri net, we show how to automatically transform it into a an executable and distributed monitoring engine. To that aim, we introduce a modification of the semantics of Petri nets to be able to execute it online on partial executions and distributed observation environments. We show how to use this formal framework to provide MINOTOR, a model-driven distributed monitoring system, describe its implementation and show its applicability on a transportation use-case.

A systematic process for eliciting safety trigger conditions is presented. Starting from a risk analysis of the monitored system, critical transitions to catastrophic system states are identified and handled in order to specify safety margins on them. The conditions for existence of such safety margins are given and an alternative solution is proposed if no safety margin can be defined. The proposed process is illustrated on a robotic rollator.

The evolution of systems during their operational lifetime is becoming ineluctable. Dependable systems, which continuously deliver trustworthy services, must evolve in order to comply with changes having different origins, e.g. new fault tolerance requirements, or changes in available resources. These evolutions must not violate their dependability properties, which leads to the notion of resilient computing. This paper presents a methodology for developing adaptive fault tolerance mechanisms, from the design to the actual runtime reconfiguration, leveraging component-based middleware which enable fine-grained manipulation of software architectures.

Supervising a system in operation allows to detect a violation of system specification or temporal properties, and is the first step required by any reconfiguration mechanism. In this work, we focus on run-time verification of temporal system properties in distributed and real-time systems. Based on a description of a property that includes events and temporal constraints, expressed as an arc timed Petri net, we automatically derive a monitoring system responsible for checking this property. The proposed approach enables the distributed verification of system properties. Our contribution is twofold. On the theoretical side, we introduce a slight modification of the semantics of Petri nets to be able to execute it in partial executions and noisy observation environments. On the practical side, we show how to use this formal framework to provide a distributed and efficient monitoring system, and describe its current implementation.

In this paper, we present a middleware architecture for dependable mobile systems and an experimentation platform for its evaluation. The proposed architecture includes three building blocks tailored for mobile cooperative applications: a Proximity Map, a Trust and Cooperation Oracle, and a Cooperative Data Backup service. To illustrate our platform, we developed a Distributed Black-box application, whose aim is to record critical data while tolerating the failure of a node, and implemented a hardware evaluation platform of mobile systems for experimenting with the application. We provide here some insights on the development of the platform, focusing on wireless communication emulation via signal attenuation.

In this work, we present a platform for testing algorithms on mobile systems. We advocate that the interest of the platform lies in many aspects: it shows that simulators are not accurate, especially with regards to wireless communication and delays assumptions. Such a platform can be used to refine simulators assumptions. Moreover, to the best of our knowledge, our platform is the first attempt to implement mobility patterns, that permit to test multiple distributed algorithms in the same movement configuration, allowing for reproducible experiments. Last, but not least, we want to open our platform to test other distributed and mobile algorithms, with the hope that it will open new problems and pose new challenges.

Error confinement technologies have proven their efficiency to improve software dependability. Such mechanisms usually require efficient error detectors to swiftly signal any misbehaviour. Real-time systems, due to their timing constraints, require a richer description of correct and/or erroneous states that includes timing aspects. This paper presents real-time error detectors that can be automatically generated from formal models of the expected behaviours of software applications. The considered specifications provide the means to define quantitative temporal constraints on the execution of the application. These detectors check at run-time that the current execution matches its specification. The paper contribution is twofold. Firstly, at the theoretical level, we provide a formal definition of the expected behaviour of such detectors, ensuring a predictable behaviour of the detector system. Secondly, at a practical level, we provide a description of the complete generation process, from the models to the code of the detector.

A concurrent object is an object that can be concurrently accessed by several processes. Two well-known consistency criteria for such objects are atomic consistency (also called linearizability) and sequential consistency. Both criteria require that all the operations on the concurrent objects can be totally ordered in such a way that each read operation obtains the last value written into the corresponding object. They differ in the meaning of the word "last" that refers to physical time for atomic consistency, and to logical time for sequential consistency. This paper investigates the merging of these consistency criteria in a multiprocess program. The proposed combination offers two read operations to the processes, namely, an atomic read operation and a sequentially consistent read operation. While the first provides a process with the last "physical" value of an object, the second provides it with a value that is approximate with respect to real-time but whose semantics is perfectly well defined. A protocol that implements the combination on top of an asynchronous distributed system is described. The protocol provides a better understanding of the similarities and differences between these consistency criteria. Moreover, the protocol is generic in the sense that it can be tailored to provide only one of these consistency criteria.

This short paper characterizes a round-based synchronous (timely) computing model that is equivalent to the popular crash prone round-based asynchronous (time-free) distributed computing model. Equivalence means here that any problem that can be solved by a protocol in one model can be solved by the same protocol in the other model. The style of this note is voluntarily informal. Its aim is mainly pedagogical. Its ambition is to help better understand relations linking synchronous and asynchronous distributed computing systems, and the nature of failures that make them difficult to master.

No abstract available.

In a previous paper we introduced the condition-based approach, consisting of identifying sets of input vectors, called conditions, for which there exists an asynchronous protocol solving consensus despite the occurrence of up to f process crashes, and characterized this set of conditions, @@@@wkf. Here, we investigate @@@@wkf from the complexity perspective, and show that this class consists of a hierarchy of classes of conditions, @@@@[d]f, where d, 0 ⪇ d ⪇ f, is the degree of the condition, each one strictly contained in the previous one. The value f - d represents the “difficulty” of the class @@@@[d]f: we present a generic condition-based protocol that can be instantiated with any C ∈ @@@@[d]f, and solve consensus with (2n + 1) [log2([(f - d)/2] + 1)] shared memory read/write operations per process. For each d we present two natural conditions, C1[d]f and C2[d]f, that might be useful in practice, and we use them to show that the class containments stated above are strict. Various properties of the hierarchy are also derived. Mainly, it is shown that a class can be characterized in two equivalent but complementary ways: one is convenient for designing protocols while the other is for analyzing the class properties.