Blog

Say which of the following is true and fully explain every part of the answer (the cases where the statement applies and the cases where it does not). Mutual exclusion must be enforced in the following scenarios: 1. On any shared memory, whether it is modifiable or not. 2. On any modifiable memory, whether is it shared or not. 3. Even on memory that is neither shared nor modifiable. 4. Only on memory that is both shared and modifiable.  

Explain the terms master and slave in a distributed system. In your answer include an example of something a master has to do that a slave does not, and something a slave has to do that a master does not.

Explain how threading can be used to improve the user experience of waiting for a program to run all of the preliminary tasks that must occur for the program can actually be used. Obviously, this question is asking for something that specifically relates to the given scenario, not just a general advantage of multithreading that applies to all scenarios of a programming running.

What is a peripheral device and what is its relationship to operating systems?

What is an advantage of threading that applies only to a system with more than one processor? Explain why this advantage doesn’t apply to a single processor.

Can a process transition directly from running to suspended-blocked? If so, explain what would cause this transition. If not, explain why not.

Below is the pseudocode of the fourth version of Dekker’s algorithm. Fully explain the problem with this algorithm. Note: The code of the threads (after the first three lines) is written TWICE in this question. The first time, the code of the two threads are side-by-side to make it easier to compare them. But in case this does not show up properly on your screen, the code is written again with T2’s code written AFTER T1’s. boolean t1WantsToEnter = false;boolean t2WantsToEnter = false;startThreads();*** SIDE BY SIDE ***// T1:                                                        // T2:while (!done) {                                               while (!done) {   // non-critical code goes here                                // non-critical code goes here   t1WantsToEnter = true; // this line marks                     t2WantsToEnter = true; // this line marks                          // entering mutual exclusion                                  // entering mutual exclusion  while (t2WantsToEnter) {                                      while (t1WantsToEnter) {      t1WantsToEnter = false;                                       t2WantsToEnter = false;      // here the code sleeps a small amount of time                // here the code sleeps a small amount of time      t1WantsToEnter = true;                                        t2WantsToEnter = true;   }                                                             }   // critical section code goes here                            // critical section code goes here  t1WantsToEnter = false; // this line marks                    t2WantsToEnter = false; // this line marks                           // exiting mutual exclusion                                   // exiting mutual exclusion   // more non-critical code goes here                           // more non-critical code goes here}                                                             }*** TOP AND BOTTOM ***// T1:while (!done) {   // non-critical code goes here   t1WantsToEnter = true; // this line marks                          // entering mutual exclusion   while (t2WantsToEnter) {      t1WantsToEnter = false;      // here the code sleeps a small amount of time      t1WantsToEnter = true;   }   // critical section code goes here   t1WantsToEnter = false; // this line marks                           // exiting mutual exclusion   // more non-critical code goes here}// T2:while (!done) {   // non-critical code goes here   t2WantsToEnter = true; // this line marks   // entering mutual exclusion  while (t1WantsToEnter) {      t2WantsToEnter = false;      // here the code sleeps a small amount of time      t2WantsToEnter = true;   }   // critical section code goes here  t2WantsToEnter = false; // this line marks                           // exiting mutual exclusion   // more non-critical code goes here}                                                                               }

Below is the pseudocode of Peterson’s Algorithm. Explain why indefinite postponement cannot occur in this algorithm. Note: The code of the threads (after the first four lines) is written TWICE in this question. The first time, the code of the two threads are side-by-side to make it easier to compare them. But in case this does not show up properly on your screen, the code is written again with T2’s code written AFTER T1’s. int favoredThread = 1;boolean t1WantsToEnter = false;boolean t2WantsToEnter = false;startThreads(); *** SIDE BY SIDE ***// T1:                                                            // T2:while (!done) {                                                   while (!done) {   // non-critical code goes here                                    // non-critical code goes here   t1WantsToEnter = true; // this line marks                         t2WantsToEnter = true; // this line marks                           // entering mutual exclusion                                      // entering mutual exclusion   favoredThread = 2;                                                favoredThread = 1;   while (t2WantsToEnter && favoredThread == 2) ; // spin            while (t1WantsToEnter && favoredThread == 1) ; // spin   // critical section code goes here                                // critical section code goes here   t1WantsToEnter = false; // this line marks                        t2WantsToEnter = false; // this line marks                           // exiting mutual exclusion                                       // exiting mutual exclusion   // more non-critical code goes here                               // more non-critical code goes here}                                                                 }*** TOP AND BOTTOM ***// T1:while (!done) {   // non-critical code goes here   t1WantsToEnter = true; // this line marks entering mutual exclusion   favoredThread = 2;   while (t2WantsToEnter && favoredThread == 2) ; // spin   // critical section code goes here   t1WantsToEnter = false; // this line marks exiting mutual exclusion   // more non-critical code goes here}// T2:while (!done) {   // non-critical code goes here   t2WantsToEnter = true; // this line marks entering mutual exclusion   favoredThread = 1;   while (t1WantsToEnter && favoredThread == 1) ; // spin   // critical section code goes here   t2WantsToEnter = false; // this line marks exiting mutual exclusion   // more non-critical code goes here}

Is it possible for a thread of a process to be in the running state while the process is in the blocked state? Explain your answer.

If you have separate but related tasks that need to be accomplished, compare and contrast the two approaches of using separate processes vs. separate threads.