Seeking Time-Composable Partitions of Tasks for COTS Multicore Processors Gabriel Fernandez *† , Jaume Abella † , Eduardo Qui˜ nones † , Luca Fossati § , Marco Zulianello § , Tullio Vardanega ¶ , Francisco J. Cazorla †‡ * Universitat Polit` ecnica de Catalunya, Spain † Barcelona Supercomputing Center, Spain ‡ Spanish National Research Council (IIIA-CSIC), Spain § European Space Agency, The Netherlands ¶ University of Padova, Italy Abstract—The timing verification of real-time singlecore sys- tems involves a timing analysis step that yields an Execution Time Bound (ETB) for each task, followed by a schedulability analysis step, where the scheduling attributes of the individual tasks, including the ETB, are studied from the system level perspective. The transition between those two steps involves accounting for the interference effects that arise when tasks contend for access to shared resource. The advent of multicore processors challenges the viability of this two-step approach because several complex contention effects at the processor level arise that cause tasks to be unable to make progress while actually holding the CPU, which are very difficult to tightly capture by simply inflating the tasks’ ETB. In this paper we show how contention on access to hardware shared resources creates a circular dependence between the determination of tasks’ ETB and their scheduling at run time. To help loosen this knot we present an approach that acknowledges different flavors of time composability, examining in detail the variant intended for partitioned scheduling, which we evaluate on two real processor boards used in the space domain. I. I NTRODUCTION Research on timing analysis for multicore processors is still in its infancy. This is particularly the case for COTS hardware, which to date, to the best of our knowledge, has been addressed with some success only for well-behaved – hence not especially realistic – variants. The difficulty with the timing analysis of software programs running on multicore processors thus is a serious impediment to their adoption in real-time systems industry. As asserting a single, tight, safe and absolute worst-case execution-time (WCET) bound for COTS multicore processors is still an open problem, which far exceeds the state of the art in timing analysis, in this paper we use the term Execution Time Boud, or ETB, in place of the more common WCET. Transposing to multicore processors the practice in place for traditional singlecore processors, we note that the timing analysis of a real-time system involves essentially two steps. The first step derives for each application program an ETB, computed assuming that the program runs in isolation. In the second step, all system-level overheads such as interrupts, blocking times when arbitrating access to shared resources in the program, and the preemptions that result from dynamic scheduling are taken into account, compositionally (that is to say, by capturing holistically all interference effects that result from composing software programs into the final system). Response-time analysis [19], [7] is one of the techniques typically used in the latter step, which is fed with the ETB of individual tasks, which is assumed given. In that two-step process, the ETB computed considering tasks in isolation is augmented with the time duration in which the task, though notionally holding the CPU, cannot actually progress. This timing approach in which ETB is inflated to account for system-level effects has been shown to work sufficiently well in singlecore architectures. Task scheduling is one of the system functions that affects the mosts tasks’ timing behavior. This is so because task scheduling determines when and how tasks may pre-emptively interleave, hence the extent of pre-emption effects that each task may suffer. In COTS multicore systems, task scheduling affects task pre-emption much like in singlecore systems. Unlike singlecore systems, however, scheduling in multicore systems also determines the tasks that may potentially run at the same time in the processor and hence, can conflict in the access to hardware shared resources. The latter factor, which has a massive impact on the tasks’ timing behavior, creates a nasty circular dependence between task scheduling and ETB determination in the timing analysis for COTS multicores. Attempting to compositionally extend in response-time analysis the magnitude of the ETB obtained for individual programs in isolation, with the effects of inter-task conflicts on access to processor resources is impractical in the general case. This is so because tasks may conflict so frequently (e.g. on every access to the on-chip bus) and for so many resources (caches, buses, queuing buffers, etc.) that the amount of knowledge to characterize the application usage of hardware resources required rapidly gets out of control. This calls for an alternative solution, in which on-chip contention effects are accounted for as part of the ETB determination. The much-sought property of time composability [28], [15], when transposed to a multicore processor, stipulates that the timing behavior of an individual task is not affected by the activity of its co-runners. Time composability is generally © 2015 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes,creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works. DOI 10.1109/ISORC.2015.43