Between June and 1985 and July 1987 3 patients were killed do to a race condition associated with the command screen because the software was improperly synchronized.

If process Pi is executing in its critical section, then no other process can be executing in their critical sections

If no process is executing in its critical section and some processes wish to enter their critical sections, then only those processes that are not executing in their remainder sections can participate in deciding which will enter its critical section next, and this selection cannot be postponed indefinitely

There exists a bound, or limit, on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted

1. initialize a global variable before a thread has entered the critical section and check to see what the thread is set to and set it again after the thread has exited

2. Initialization using flags

3. Use a combination of both

1.The code can be complex and hard to figure out

2. Busy Waiting

A process that is blocked is on a waiting queue, and not using the CPU. Thus, it cannot be busy-waiting, because it’s not using the CPU.

Why is turning off interrupts not a general solution for solving the critical section problem?

leads to a decrease in the responsiveness to external events. Devices often use interrupts, and if interrupts are turned off these devices (external events) cannot

be serviced. Therefore, the technique should only be used for critical sections that are very short and only by system code (i.e., the operating system).

A process is deadlocked if and only if there is no way for it to become unblocked and a blocked process is not deadlocked if there is a sequence of operations that will unblock it (not including the terminating of a process by some external event). Also, this does not imply that this sequence of operations needed to unblock will happen. In fact another sequence can lead to this process becoming deadlocked.

Can a processes RAM memory be preempted? Yes or No (Circle one). Explain. Based on your answer to this question, can RAM memory be involved as a resource in a deadlock? Yes or No. (Circle one). Explain.

Yes, since the contents of RAM can be written to disk to allow memory swapping, preemption is possible and the preempted process can always regain the information from the hard drive when it is swapped

back into RAM. No, RAM memory cannot be involved as a resource in a deadlock because it can be preempted.

How can two (heavy-weight) processes share memory in a paged memory environment? 

Two HWP’s (Heavy weight processes) can share memory in a paged

memory environment by referencing the same physical frame from

their page tables.

By default, HWP’s don’t share writable RAM. By

default, light-weight processes (threads) within a HWP share writable RAM.

Specific system calls are needed to enable HWP’s to share frames of RAM for

writing.

Which of the prior instructions required a MMU (memory management

unit) logical to physical address translation?

a. LOAD R1, R2 ; load machine register R1 from machine register R2

b. LOAD R1, Variable ; load machine register R1 from Variable

c. JMP Label1 ; unconditional branch to Label1

Each time that an (logical) address is generated and before the memory access is made, this will require a MMU logical to physical address translation. That is, once for instruction (a), twice for (b) and once for (c).

– a lock on a java Object through a synchronized method

– a lock on a Semaphore

– mutually exclusive access to a digital video camera to control position

– mutual exclusion to draw a certain object onto a computer display

– mutual exclusion to print a file to a printer

– use of a server thread instance from a pool of server threads (may be a fixed number of server threads)

• 1) Mutual exclusion

– There must be at least one resource that cannot be shared amongst processes

– “Cannot be shared”

• Request/use/release style of resource usage

• 2) Hold & wait

– There must be at least one process holding a resource and waiting on another

• 3) No preemption

– There can be no preemption of resources

– E.g., generally don’t get a deadlock with CPU resource because O/S typically uses preemptive scheduling

• 4) Circular wait

– There must be a blocked set of processes: {P0, …, PN-1}

– Where P(i+1 mod n) is waiting on a resource held by Pi

• A “snapshot” (at a particular time) of the current allocation of resources to processes

• Assumes a fixed set of processes, and a fixed set of resources

• Does not include any change in allocation of resources to processes because that is the resource allocation state over time (I.e., several resource allocation states)

1. Each process indicates the maximum number of units of each resource type it can request, before it starts requesting any resources

2. Process makes a request for resources

3. System determines, if after granting that request, whether the resource allocation state of the system will be safe

Sates that are safe are not deadlocked, and so we are assuring that the next resource allocation state of the system will not be deadlocked

4. If the next state will be safe, grant the request

5. Otherwise, block the requesting process until the request can be safely granted

6. Follow this procedure for every resource request

• A state is safe if the system can allocate resources to each process (up to its maximum) in some order and still avoid a deadlock

• A system is in a safe state only if there exists a safe sequence

1. Let Work and Finish be vectors of length m and n, respectively (n= number of processes; m = number of resources). Initialize: Work = Available

Finish [i] = false for i = 1,2,3, …, n. // dealt with process i?

2. Find i such that both:

(a) Finish [i] == false

(b) Needi ≤ Work

If no such i exists, go to step 4.

3. Work = Work + Allocationi // simulate process i terminating

Finish[i] = true

go to step 2.

4. If Finish [i] == true for all i, then the system is in a safe state. Otherwise, in unsafe state.

• Symbolic addresses

• Relocatable addresses

• Absolute (physical) addresses

Converting the (relative or symbolic) address used in a program to to an actual physical (absolute) RAM address

- During compilation (or assembly)

- During load time

- During execution

• Translates logical addresses to physical addresses

– I.e., performs address binding

• Also enables memory protection

• Relocation register

• Base & limit register

• Page table support

• Segmentation support

– All of program loaded into a single region of RAM

– Relatively simple strategy-- memory protection can be provided by a MMU with base & limit registers

1. Swapping out one process for another when needed.

2. Load a program in parts

Breaking up program into fixed size, relatively small

units of RAM

• Logical address space of process is contiguous

• However, in real memory, frames can be non contiguous

• Each logical page of a process can be stored in any (different) physical frame of RAM

Page table maps from logical page numbers of a process to frame numbers of physical RAM

A) Only frames that map through the page table can be accessed

B) Page table entries can be extended to include protection information (page-table length register can accomplish part of this goal)

Keep some page table entries in special, fast, cache memory

What is the formula for Effective Access Time (EAT)?

Why would we expect a relatively large percentage of TLB hits?

• Locality of reference!

– When program code and/or data that process is using comprise a relatively small collection of pages

When a process with a different address space is

started, we may not be able to use the same TLB

entries. Why?

Because the new address space has a different page table, which provides different mappings from logical page numbers to frame numbers.

 because your accessing it using an index and it wouldn't make sense to have a page table of a page table.

because much of our other RAM is allocated non contiguously in pages, we may be able to obtain such large contiguous regions of memory