SimTrOS : شبیه ساز سطح انتزاعی ناهمگن برای هماهنگ سازی چند هسته ای در سیستم های زمان واقعی

To provide a common ground for the comparison of real-time multicore synchronization protocols we developed a framework that supports heterogenous levels of abstraction for simulated functionality and simulated timing. Our intention is to make the simulator available to the real-time research community and industrial users. For the latter we initially focus on automotive real-time systems. This paper describes the simulation framework and the novel idea of heterogenous abstraction levels that lies at the heart of its design. Notwithstanding the clear focus, we believe that the simulator itself as well as the concept of heterogenous abstraction levels can be useful in a significantly broader way.

For real-time researchers it is important to demonstrate the benefits of novel approaches in comparison to previous ones. However, it can be a tedious job to achieve a comparison on equal terms, since this usually requires implementing concepts and evaluation infrastructures of other groups. Moreover, the transferability of the evaluation results to an industrial context is quite limited, as the original comparison ignores the caveats of a particular product context for good reasons. Unfortunately, important qualities (e.g. memory consumption, temporal implementation overhead, or energy demand) of a solution are often sensitive to the ignored factors, thus rendering too general results useless. We believe that, due to the lack of scalable and transferable evaluations, many valuable concepts of our community are not appreciated in the way they would deserve and the adoption by industry is significantly smaller and slower than it could be. A reason for this is the lack of scalable and transferable evaluations. As it is infeasible to investigate each solution a priori in every potential industrial usage scenario, the comparison approaches should allow for a fast re-exploration considering a concrete product context. We developed the simulation framework described in this paper to tackle these issues for multiprocessor resource locking protocols, especially in the context of automotive real-time systems. Notwithstanding this clear focus, we believe that the simulator core itself can be used for any timing evaluation of multicore real-time systems and moreover, that the novel idea of heterogenous abstraction levels that lies at the heart of its design can also be a key to fast re-exploration when investigating further runtime properties such as memory or energy consumption. Efforts to migrate legacy applications to multicore systems, such as the one sketched in [16], which led to the development of the described simulator, require sound multicore synchronization mechanisms. Moreover, automotive industry identified in its AUTOSAR real-time operating system standard the need for resource locking protocols in future multicore systems [3]. However, none of the available approaches (e.g. [13], [7] and [4]) has been chosen so far, nor was any suitable replacement incorporated into the standard. Comparison studies such as the ones by Brandenburg and Anderson [5] and by Lakshmanan et al. [10] are of no help for the automotive industry as they come to diverging conclusions. One result is in favor of spin-based the other in favor of suspension based schemes. In our opinion it is evident that the question of which multicore resource locking protocol is better can only be decided for a given characteristic of an application and a given implementation of the protocol in a particular operating system, e.g. AUTOSAR. Furthermore, we conjecture that the hardware characteristics of automotive systems such as low processing power can have a significant effect on the outcome of this question. As briefly described in [17] and [15] our SimTrOS simulator is designed to deliver detailed results about the suitability of different protocols and their implementation overhead for the specific characteristics of automotive applications. The design of the simulator was driven by the following central requirements: 1. Modelling of applications and operating system services, e.g. multicore resource locking protocols, shall be decoupled. 2. The two simulation concerns functionality and temporal behavior shall be strictly separated. 3. Any simulation result shall be deterministically reproducible, i.e. even if a system with race conditions is simulated, the simulator shall produce the same output if it receives identical input. Otherwise incremental changes of the simulated system might become indistinguishable from random effects. Note that variability of the simulation can be achieved by using different seed values for pseudorandom number generation.

We presented the design of a novel simulator. The key idea of heterogenous abstraction levels allows the user to simulate a system with different timing parameters, without changing the functional behavior. This scheme was chosen to allow for a fast exploration of multicore real-time synchronization protocols in different implementation flavors for their employability in industrial automotive systems. We conjecture that the approach is equally suited to compare other mechanisms such as scheduling or resource handling in mixed-criticality systems [14] regarding their sensitivity to implementation overhead, e.g. context switches. Moreover, the idea of strict separation of timing and functionality is, as we believe, well suited to be used in many simulation approaches in the field of analysis of non-functional properties apart from timing. The modular design of the simulator and its separation in application, i.e. task sets and external events, and operating system layer, i.e. API-calls, is another key feature aimed at easy usage. We intend to provide the simulator as an open tool to the research community and to successively build up a repository of simulation code for real-time operating systems and applications. We started implementing different multicore resource locking protocols on top of an AUTOSAR system model. The next step is providing better ways to examine simulation results such as a tool that extracts statistics from the produced XML output of the simulator, e.g. average or observed worst-case execution, or blocking times of jobs. For visualization of simulator runs we plan to leverage existing tools, e.g. translating the output of the simulator to the input format of the Grasp tool [8]. A more remote goal could be to generalize the principle of heterogenous abstraction levels for the simultaneous investigation of multiple non-functional run-time properties such as energy demand, or memory consumption in addition to timing.