1. Problems discussed in the review session for the second midterm
COSC 4330/6310
Summer 2012

2. Scheduling
How would you simulate a round-robin policy with a time slice of 100 ms on a System V R 4 system?
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL

3. Answer
How would you simulate a round-robin policy with a time slice of 100 ms on a System V R 4 system?
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL #0

4. Scheduling Consider the following System V Release 4 scheduler:
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL # # # # 3
and assume that a process at priority level 2 receives 800 ms of CPU time before doing an I/O.

5. Answer
Start at priority 2 and get 200 ms of CPU time before returning to the ready queue
New priority given by __________

6. Answer
Start at priority 2 and get 200 ms of CPU time before returning to the ready queue
New priority given by ts_tqexp
Move to priority 1 and get 500 ms of CPU time before returning to the ready queue
New priority given by _______

7. Answer
Start at priority 2 and get 200 ms of CPU time before returning to the ready queue
New priority given by ts_tqexp
Move to priority 1 and get 500 ms of CPU time before returning to the ready queue
Move to priority 0 and get 100ms of CPU time before doing an I/O
New priority given by _______

8. Answer
Start at priority 2 and get 200 ms of CPU time before returning to the ready queue
New priority given by ts_tqexp
Move to priority 1 and get 500 ms of CPU time before returning to the ready queue
Move to priority 0 and get 200ms of CPU time before doing an I/O
New priority given by ts_slpret: level 1

9. Another answer to the problem (I)
Step 1: Process is at priority level 2
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL # # # # 3
and requests 800 ms of CPU time
It gets only 200 ms and returns to the CPU queue at the level indicated by ts_tqexp

10. Another answer to the problem (II)
Step 2: Process is now at priority level 1
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL # # # # 3
and requests 600 ms of CPU time
It gets only 500 ms and returns to the CPU queue at the level indicated by ts_tqexp

11. Another answer to the problem (III)
Step 3: Process is now at priority level 0
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL # # # # 3
and requests 100 ms of CPU time
It gets only the 100 ms then goes to the waiting state

12. Another answer to the problem (IV)
Step 4: Process is still at priority level 0
#ts_quantum ts_tqexp ts_slpret ts_maxwait ts_lwait LVL # # # # 3
When it returns to the ready queue, it gets upgraded to the priority level specified by ts_slpret
Goes to priority level 1

13. Short question
What is the major limitation of non-preemptive scheduling policies?

14. Answer
Non-preemptive policies allow processes to monopolize the CPU.

15. Short question
What does the System V Release 4 scheduler do to avoid process starvation?

16. Answer
It increases the priority of processes that have waited more than ts_maxwait time units in the ready queue.

17. Short question
What is the idea behind penalizing processes that have already got their share of the CPU?

18. Answer
To ensure that the other processes can get their fair share of the CPU.

19. Short question
What is the difference between blocking sends and non-blocking sends?

20. Answer
A blocking send waits until the message has been received by the process to which it was addressed
A non-blocking send returns as soon as the message has been accepted for delivery.
Like a letter dropped in a mailbox.

21. Short question
Can you simulate a non-blocking send—or receive—using only blocking sends and receives?

22. Answer
No, but you can simulate blocking sends—or receives—using only non-blocking sends and receives.

23. Short question
What is the difference between virtual circuits and datagrams?

24. Answer
Virtual circuits are connection-oriented and ensure that all messages will arrive in the right order without any of them being lost, damaged or duplicated.
Datagrams are sent individually.

25. Short question
How would you pass a linked list to a remote procedure?

26. Answer By storing it in array along with unpacking instructions. A B CD LL 4 A B C D

27. Short question
How can we solve the big-endian/little endian issue?

28. Answer
We can require all transfers to use an arbitrary network order, the same for all computers.

29. Short question
What is the major advantage of idempotent procedures?

30. Answer
Idempotent procedures can be repeated an arbitrary number of times without causing any harm.
Hence, we do not have to worry about incomplete executions.
We restart the procedure.

31. Short question
What is the main disadvantage of atomic transactions?

32. Answer
Their cost.
At the same time they remain indispensable in financial transactions.

33. Short question
What is the difference between the at most once and the all or nothing semantics in RPCs?

34. Answer
The at most once semantics guarantees that no RPC call will be executed more than once but does not prevent partial executions, which the all or nothing semantics does.

35. Busy waits
Why should we avoid busy waits?
Is this always true?

36. Answer
Busy waits waste computing cycles. There are especially bad on single processor architectures because the process doing the busy wait will repeatedly interrupt the process on which it is waiting.
They are the best solution for short waits on multiprocessor/multicore architectures as long as the expected wait time is less than to context switches.

37. Problem Consider the function
transfer(int *from, int *to, int amount) { *from -= amount; *to += amount; } // transfer
and assume the calling sequence:
alpha = 100; beta = 200; transfer (&alpha, &alpha, 10)

38. Problem (continued)
What will be the value of alpha after the call assuming that
(a) the call was a regular procedure call?
(b) the call was a remote procedure call?

39. Solution (a) If the call was a regular procedure call, a = 100
(b) If the call was a remote procedure call, a = 90 or 110

40. Explanation With a regular procedure call &alpha, &alpha, 10
Calling Program
doubletrouble
Debits &alpha
alpha = 100
Credits same amount to &alpha

41. Explanation (cont'd) With a remote procedure call 100, 100, 10
Calling Program
doubletrouble
90, 110
alpha = 90 or 110

42. What is wrong? shared int reserved[2] = {0, 0};
void enter_region(int pid) { while (reserved[1-pid]); // busy wait reserved[pid] = 1; } // enter_region
void leave_region(int pid) { reserved[pid] = 0; } // leave_region

43. Answer
The functions do not guarantee mutual exclusion when processes 0 and 1 enter in lockstep.
The two critical steps are: while (reserved[1-pid]); // test lock reserved[pid] = 1; // set lock

44. The ice-cream parlor
An ice-cream parlor has two employees selling ice cream and six seats for its customers. Each employee can only serve one customer at a time and each seat can only accommodate one customer at a time. Add the required semaphores to the following program skeleton to guarantee that customers will never have to wait for a chair with a melting ice-cream in their hand.

45. The ice-cream parlor (cont'd)
semaphore _______________ = ______; semaphore _______________ = ______; customer (int who) { ______________________________ order_ice_cream(); ______________________________ eat_it(); ______________________________ } // customer

46. Sketching a solution Two resources are shared by all customers
Six seats
Two employees
Questions to ask are
When should we request a resource?
In which order? (very important)
When should we release it?

47. Solution
semaphore _seats__________ = __6___; semaphore _employees______ = _ 2___; customer (int who) { ______________________________ order_ice_cream(); ______________________________ eat_it(); ______________________________ } // customer

48. Solution (cont'd) Get seat first
semaphore _seats__________ = __6___; semaphore _employees_____ = __2___; customer (int who) { P(&seats); P(&employees);________; order_ice_cream(); ______________________________; eat_it(); ______________________________; // customer
Get seat first

49. Solution (cont'd) What is missing?
semaphore _seats__________ = __6___; semaphore _employees______ = __2___; customer (int who) { P(&seats); P(&employees);________ order_ice_cream(); V(&employees);_________________ eat_it(); ______________________________ } // customer
What is missing?

50. Solution (cont'd)
semaphore _seats__________ = __6___; semaphore _employees______ = __2___; customer (int who) { P(&seats); P(&employees);________ order_ice_cream(); V(&employees);_________________ eat_it(); V(&seat);______________________ } // customer

51. The pizza oven
A pizza oven can contain nine pizzas but the oven narrow opening allows only one cook at a time to either put a pizza in the oven or to take one out. Given that there will be more than one cook preparing pizzas at any given time, complete the missing lines in the following C procedure.

52. The pizza oven (cont'd) semaphore oven = ______;
semaphore access = _______;
make_pizza(int size, int toppings) {
prepare_pizza(size, toppings); ______________________________________ put_into_oven(); ______________________________________ wait_until_done(); ______________________________________ take_from_oven(); ______________________________________
} // make_pizza

53. Sketching a solution The two resources are already identified The oven
Access to the oven (mutex)
We ask the usual questions
And take care of avoiding mutex-induced deadlocks

54. Solution semaphore oven = ___9__;
semaphore access = __1__; // the mutex
make_pizza(int size, int toppings) {
prepare_pizza(size, toppings); ______________________________________ put_into_oven(); ______________________________________ wait_until_done(); ______________________________________ take_from_oven(); ______________________________________
} // make_pizza

55. Solution (cont'd) Order matters! semaphore oven = ___9__;
semaphore access = __1__; // the mutex
make_pizza(int size, int toppings) {
prepare_pizza(size, toppings); P(&oven); P(&access);__________________ put_into_oven(); ______________________________________ wait_until_done(); ______________________________________ take_from_oven(); ______________________________________
} // make_pizza
Order matters!

56. Solution (cont'd) semaphore oven = ___9__;
semaphore access = __ 1__; // the mutex
make_pizza(int size, int toppings) {
prepare_pizza(size, toppings); P(&oven); P(&access); ____________________ put_into_oven(); V(&access);____________________________ wait_until_done(); P(&access);____________________________ take_from_oven(); V(&oven); V(&access); // IN ANY ORDER!____
} // make_pizza

57. The pizza oven (again)
Redo problem 2 using monitors.

58. The pizza oven (again)
Class oven { private int n_pizzas; // in oven private condition not_full; public void synchronized put_a_pizza() { _______________________________ _______________________________ put_a_pizza_in_the_oven(); ______________________________ ______________________________
} // put_a_pizza()

59. The pizza oven (again) (Class oven continued)
public void synchronized remove_a_pizza() { ______________________________ ______________________________ take_a_pizza_from_the_oven(); ______________________________ ______________________________
} // remove_a_pizza()

60. The pizza oven (again)
(Class oven continued) oven() { n_pizzas = 0; } // constructor
} // Class oven

61. Sketching a solution Two monitor procedures instead of a C function
Each procedure handles a step that must be performed in mutual exclusion
Questions to ask are
When do we have to wait on a condition?
Must be specific
Which conditions do we need to signal?

62. Solution
Class oven { private int n_pizzas; // in oven private condition not_full; public void synchronized put_a_pizza() { if (n_pizzas == 9) notfull.wait; _____ n_pizzas++;____________________ put_a_pizza_in_the_oven(); ______________________________ ______________________________ } // put_a_pizza()

63. Solution (cont'd) (Class oven continued)
public void synchronized remove_a_pizza() { ____________________________ ____________________________ take_a_pizza_from_the_oven(); n_pizzas--;___________________ notfull.signal;_________________ } // remove_a_pizza()

64. Solution (cont'd) (Class oven continued)
oven() { n_pizzas = 0; } // constructor
} // Class oven

65. More on monitors
How should you modify a monitor when you replace its signal calls by notify calls?

66. More on monitors
How should you modify a monitor when you replace its signal calls by notify calls?

67. Answer
How should you modify a monitor when you replace its signal calls by notify calls?
All if(…) clauses preceding waits should be replaced by while(…) clauses.

68. True or false
You should always initialize mutex semaphores to one.

69. Answer
You should always initialize mutex semaphores to one.
TRUE

70. True or false
You should always initialize monitor conditions to zero.

71. Answer You should always initialize monitor conditions to zero.
FALSE monitor conditions have NO VALUE

72. True or false
Many good programmers prefer to put all their signal operations at the end of their monitor procedures.

73. Answer
Many good programmers prefer to put all their signal operations at the end of their monitor procedures.
TRUE Issuing a signal means risking to be interrupted in the middle of its critical section