Dynamic Versus Stasic System

DYNAMIC VERSUS STATIC SYSTEMS
In the above example, jobs that are ready for execution are placed in a priority queue common to all processors. When a processor is available, the job at the head of the queue executes on the processor. We will refer to such a multiprocessor system as a dynamic system, because jobs are dynamically dispatched to processors. In the example in Figure 4–2, we allowed each preempted job to resume on any processor and hence, jobs are migratable. We say that a job migrates if it starts execution on a processor, is preempted, and later resumes on a different processor.

Another approach to scheduling in multiprocessor and distributed systems is to partition the jobs in the system into subsystems and assign and bind the subsystems statically to the processors. Jobs are moved among processors only when the system must be reconfigured, that is, when the operation mode of the system changes or some processor fails. Such a system is called a static system, because the system is statically configured. If jobs on different processors are dependent, the schedulers on the processors must synchronize the jobs according to some synchronization and resource access-control protocol. Except for the constraints thus imposed, the jobs on each processor are scheduled by themselves.

As an example, a partition and assignment of the jobs in Figure 4–2 put J1, J2, J3, and J4 on P1 and the remaining jobs on P2. The priority list is segmented into two parts: (J1, J2, J3, J4) and (J5, J6, J7, J8). The scheduler of processor P1 uses the former while the scheduler of processor P2 uses the latter. It is easy to see that the jobs on P1 complete by time 8, and the jobs on P2 complete by time 11. Moreover, J2 completes by time 4 while J6 starts at time 6. Therefore, the precedence constraint between them is satisfied.

In this example, the response of the static system is just as good as that of the dynamic system. Intuitively, we expect that we can get better average responses by dynamically dispatching and executing jobs. In later chapters we will return to this discussion. Specifically, we will demonstrate that while dynamic systems may be more responsive on the average, their worst-case real-time performance may be poorer than static systems. More importantly, we do not yet have reliable techniques to validate the timing constraints of dynamic systems while such techniques exist for static systems. For this reason, most hard real-time systems built today are static.