Comments: MetaH seems like a nice integrated set of tools for building real-time systems; this paper provides a short, nontechnical overview.
Comments: A useful, but not particularly technical, overview of the current state of the academic research in embedded systems.
Comments: Simple scheduling theories are nice, in theory. In practice, scheduling theory has to be quite complex to handle real-world factors such as context switch overheads, non-preemptible sections, etc. This paper is about how to accurately model an actual real-time OS; it's worth reading.
Comments: A short, useful paper.
Comments: This paper describes a clever way to authenticate broadcast communications with low overhead and tolerance to dropped messages.
Comments: I don't know that much about this area, but if this paper is to be believed Athena is the best thing since sliced bread for security protocol analysis. Cool stuff.
Comments: Port-based objects provide a restricted programming environment for writing real-time systems, where races and deadlocks are impossible. This is definitely worth reading.
Comments: A key to providing a good programming model is to take dangerous or useless freedom away from the programmer, while leaving enough freedom to solve the problem in a natural and appropriate way. This is a nice little paper about how to do this in the context of real-time systems.
Comments: Intuitively, a real-time task set is sensitive to timing faults if small changes in worst-case execution time cause deadlines to be missed. Since WCETs are often not precise, sensitivity analysis is an important part of building robust real-time systems. For some reason, however, it hasn't attracted a lot of academic interest. This paper is mathematically intensive since it takes an analytic approach to sensitivity analysis.
Comments: The first part of this paper -- the part that provides the exact characterization and introduces the notion of breakdown utilization -- is brilliant. The rest of the paper is overly complicated for the value it provides: an analysis of the behavior of random task sets. Showing the results of a simulation study would have been more readable and more enlightening.
Comments: This is a nice paper, although somewhat oddly titled. It builds on the authors' previous work on preemption thresholds, which I think is some of the neatest scheduling work in recent years. The contributions of this paper are an algorithm for jointly assigning thresholds and priorities, a quantification of the benefits of preemption thresholds, and an algorithm for coalescing tasks into threads in order to save memory and reduce context switches.
Comments: This paper is useful for several reasons. First, it provides a good summary of existing theoretical results in priority-based real-time uniprocessor scheduling. And second, it fills some gaps in the theory. As far as I'm concerned, the most important contribution is the realization that static-priority preemptive and non-preemptive scheduling are governed by very similar equations; this observation paves the way for interesting later research such as the work on preemption thresholds.
Comments: When I read the Cyclone summary paper I had no idea how elaborate the system for supporting safe and convenient usage of regions was. I had previously avoided regions papers since they tend to be pretty heavy on the type theory. This paper goes into gory detail about how the regions work and how the Cyclone developers have made minimizing developer burden their main priority -- certainly a sensible approach. Also, the paper is probably a good regions introduction for systems (read: non-programming language) people since it keeps the Greek letters to a minimum.
Comments: When the deadline of a real-time task is longer than its period, analysis becomes complicated because (potentially) many instances of the task can overlap. The analysis in this paper extends each of the results covered in YCS 120 to cover this case.
Comments: The response-time analysis of task sets preemptively scheduled by a fixed priority scheduler was pioneered by Joseph and Pandya; subsequent work at York and CMU generalized this to form a very general framework for reasoning about static priority scheduling. For tasks with deadlines less than or equal to periods, this paper presents analysis taking release jitter, precedence constraints, and sporadically periodic tasks in account. This is a great paper.
Comments: No new content, but this is an interesting read. Possibly it's part of an attempt to set the record straight with the CMU folks about who deserves credit for what parts of static priority / rate monotonic analysis?
Comments: Architecture description languages (ADLs) permit high-level specification of software systems. Typically, an ADL will encode a number of domain-specific assumptions about a particular kind of system. For example, connectors might be function calls, RPCs, shared variables, or a variety of other things. The structure of the system might be static or dynamic, real-time or non-real-time. And so on. Acme is agnostic with respect to these concerns: it encodes a few simple concepts like components and connectors and also provides an "open semantic framework" for encoding the domain-specific stuff. My main concern is that maybe the authors have "pulled an XML" by deferring all the hard work. Still, this paper is worth reading.
Comments: Looks like a cool language and I'd like to try it out. The authors claim, but did not quite convince me, that run-time overhead introduced by Cyclone will be predictable and under programmer control. Cf pages 61-64 of The Art of Designing Embedded Systems by Jack Ganssle. Still, Cyclone looks to be an attractive alternative to ML, Java, or Modula for type-safe systems-level programming.
Last modified: Wed Oct 10 09:24:57 MDT firstname.lastname@example.org