Thermal and power problems impose limits on the performance that single-processor chips can deliver. Multicore architectures (or chip multiprocessors), which include several processors on a single chip, are being widely touted as a way to circumvent this impediment. Several chip manufacturers already have released chips with a small number of processors, and 32-processor systems are predicted within the decade. For software designs to take advantage of the parallelism available in these systems, careful attention must be paid to resource-allocation issues. For throughput-oriented applications, initial work on such issues has begun. However, almost no such work has targeted real-time applications, which require very different resource-allocation methods, as they need performance guarantees. This project investigates synthesis of real-time applications on multicore systems. The focus is soft real-time applications, in which some deadline misses are tolerable, but hard real-time applications, in which deadlines can never be missed, are also of concern.
In multicore systems, care must be taken when scheduling and synchronizing tasks in order to avoid thrashing shared on-chip caches. In real-time systems, timing constraints must be ensured as well. This project is developing an allocation framework that addresses both concerns. The thesis is that such a framework should be based upon global real-time scheduling algorithms. Such algorithms are more flexible than the alternative, partitioning approaches. This flexibility yields two advantages. First, global algorithms are better able to use information about cache behavior to influence co-scheduling choices. Second, such algorithms can be immunized from the bin-packing problems that plague partitioning approaches. In real-time systems, such problems can result in the need to place restrictive caps on overall utilization, wasting resources. Preliminary research confirms flexibility of the approach in its ability to ensure timing constraints, while encouraging low miss rates in shared caches. Research issues include how to support dynamic workloads, cache-aware real-time synchronization, and cache-profiling for real-time applications. Operating-system components developed by the project will be made available to the research community.
