This paper addresses embedded multiprocessor implementation of iterative, real-time applica tions, such as digital signal and image processing, that are specified as dataflow graphs. Schedul ing dataflow graphs on multiple processors involves assigning tasks to processors (processor assignment), ordering the execution of tasks within each processor (task ordering), and determin ing when each task must commence execution. We consider three scheduling strategies: fully- static, self-timed and ordered transactions, all of which perform the assignment and ordering steps at compile time. Run time costs are small for the fully-static strategy; however it is not robust with respect to changes or uncertainty in task execution times. The self-timed approach is tolerant of variations in task execution times, but pays the penalty of high run time costs, because processors need to explicitly synchronize whenever they communicate. The ordered transactions approach lies between the fully-static and self-timed strategies; in this approach the order in which proces sors communicate is determined at compile time and enforced at run time. The ordered transac tions strategy retains some of the flexibility of self-timed schedules and at the same time has lower run time costs than the self-timed approach.
In this paper we determine an order of processor transactions that is nearly optimal given informa tion about task execution times at compile time, and for a given processor assignment and task ordering. The criterion for optimality is the average throughput achieved by the schedule. Our main result is that it is possible to choose a transaction order such that the resulting ordered trans actions schedule incurs no performance penalty compared to the more flexible self-timed strategy, even when the higher run time costs implied by the self-timed strategy are ignored.