Matthew Williams

000-097-066
October 22nd, 2022
CISB 305
Professor Clarke
Assignment 3
1. Give an example from real life of busy waiting.

Answer
Ann Mchoes states that busy waiting is a process where the device’s CPU will place a
process in a wait loop which requires context switching. This occurs because the processes
will constantly check for the required key (McHoes & Flynn, 2018, p. 180). An real life
example of this is would be a phone call. When the division of youth called me to notify me
of my nomination for the national youth awards. Most likely their phone did not have a
voicemail or call waiting enabled so when I attempted to call back the ministry was probably
making other calls. So when I returned the call I was told that the line was busy. Thus I had
to make numerous calls until the call becomes free. The call becoming free acts the key, and
me constantly calling shows the loop.

2. What steps does a well-designed multiprocessing system follow when it detects that a
processor is failing.
Answer
Ann Mchoes elaborates on what happens when the system detects a failure on page 172 of
her book Understanding Operating systems. Based on her elaboration when one processor fails
the others may continue to operate and therefore absorb the load from the processor which is
failing. Unfortunately this can only occur if the system was designed to allow it upon which the
the system attempts to repair the failing processor which give signals to the other processors to
take its processes (McHoes & Flynn, 2018).

3. Compare the processors’ access to printers and other I/O devices for the master/slave and the
symmetric multiprocessing configurations. Give a real-life example where the master/slave
configuration might be preferred.

Answer
Ann Mchoes elaborates on the master/slave configuration being an asymmetric
multiprocessing system thus each “slave” is managed by a “master”. With this in mind the
master processor would have to grant access to each input/output device for example a
printer as it would be recognized as a slave thus it wouldn’t have direct access to main
memory unlike in a symmetric multiprocessing configuration where I/O devices have direct
access to the main memory (McHoes & Flynn, 2018, p. 175). Therefore a real life example of
this would be the student government association in some universities, in some universities
 students must reach out to their student senator and give their complaints to them. Afterwards
those senators will relay that information to the university administration and assist students,
this may be preferred to the senators knowing who to contact which mitigates the amount of
time wasted.

4. Compare the processors’ access to main memory for the loosely coupled configuration and
the symmetric multiprocessing configurations. Give a real-life example where the symmetric
configuration might be preferred.

Answer
Ann Mchoes elaborate on how loosely coupled configuration works, in this configuration
“each processor has its own dedicated resources” but it also allows “each processor [to]
communicate and cooperate with the others” (McHoes & Flynn, 2018, p. 176). With this in
mind the difference between this and symmetric multiprocessing configuration is that with
symmetric multiprocessing configuration the processors do no communicate with each other.
But the latter is more reliable, uses resources effectively and balance loads well. A real life
example of symmetric configuration is a group of students in CISB305 doing a group project
and all are using a shared google docs file which allows them to edit the paper at the same
time. Thus they are all accessing the same resources the same time and with it being efficient
it would be preferred.

5. Describe in your own words the concept of “explicit parallelism” without repeating this
book’s definition of the term.
Answer
Ann Mchoes elaborates that explicit parallelism is “to explicity state which instructions
can be executed in parallel” (McHoes & Flynn, 2018, p. 192). With this in mind explicit
parallelism can be said to be a parallel processing system which forces or allows
programmers to annotate their program to state which parts should be completed as an
independent parallel task. Unfortunately though, this style burdens the compiler is reduced as
parallelism specified explicity.