1 CS 345 Stallings Chapter Project 1 Computer

1 CS 345 Stalling’s Chapter # Project 1: Computer System Overview 2: Operating System Overview 4 P 1: Shell 3: Process Description and Control 4: Threads 4 P 2: Tasking 5: Concurrency: ME and Synchronization 6: Concurrency: Deadlock and Starvation 6 P 3: Jurassic Park 7: Memory Management 8: Virtual memory 6 P 4: Virtual Memory 9: Uniprocessor Scheduling 10: Multiprocessor and Real-Time Scheduling 6 P 5: Scheduling 11: I/O Management and Disk Scheduling 12: File Management 8 P 6: FAT Student Presentations 6

Tip #11: Saturated Addition 2 n How do you add two numbers without overflow? n n n Normally, when an addition overflows, it just drops back down to 0 and you're left with however much is left over after the overflow. If you were doing something like calculating the distance between two points, and it overflows, the points would appear to be very close to each other. Using these functions, you still won't know how far apart they are, but you'll be able to see that the points are very far apart (at least 0 x. FFFF, in the case of 32 bits). The functions can easily be adapted to 8 or 64 bit operations at well. There is significant overhead in function calls, so consider in-lining the functions or changing them to macros instead. A similar approach can be used for subtraction, multiplication, and division, although multiplication and division will be more difficult than subtraction due to more edge cases. #include <stdint. t> uint 16_t saturateadd 16(uint 16_t a, uint 16_t b) { return (a > 0 x. FFFF - b) ? 0 x. FFFF : a + b; } uint 32_t saturateadd 32(uint 32_t a, uint 32_t b) { return (a > 0 x. FFFF - b) ? 0 x. FFFF : a + b; }

Chapter 5 Concurrency: Mutual Exclusion and Synchronization

Chapter 5 Learning Objectives 4 n n n Discuss basic concepts related to concurrency, such as race conditions, OS concerns, and mutual exclusion requirements. Understand hardware approaches to supporting mutual exclusion. Define and explain semaphores. Define and explain monitors. Explain n n Producer/Consumer Bounded buffer Readers/writers problem Classical synchronization problems

Mutual Exclusion Review… 5 n Mutual exclusion requirements: 1. The OS must keep track of active processes. 2. The OS must allocate and deallocate resources. § § Processor time Memory Files I/O devices 3. The OS must protect the data and physical resources. 4. The results of a process must be independent of the speed of execution relative to the speed of other concurrent processes.

Cooperation 6 n n A cooperating process is one that can affect or be affected by other processes executing in the system. A race condition occurs when the outcome depends on the particular order of execution, most often associated with shared resources. n n Share logical space (threads) Files or messages Concurrent or parallel execution Mutual exclusion prevents race conditions by synchronizing resource access.

Resource Allocation 7 n Shared resources are n n n Produced Consumed Resource sharing presents problems of n Mutual Exclusion n Deadlock n n n Critical resource – a single non-sharable resource. Critical section – portion of the program that accesses a critical resource. Each process owns a resource that the other is waiting for. Two processes are waiting for communication from the other. Starvation n A process is denied access to a resource, even though there is no deadlock situation.

Producer/Consumer 8 The Producer-Consumer Problem Shared variables: buffer[], counter = 0, n = 128; Producer Consumer repeat … produce an item in nextp … while (counter == n); buffer[in] = nextp in = (in + 1) mod n counter = counter + 1 repeat … while (counter == 0); nextc = buffer[out] out = (out + 1) mod n counter = counter - 1 … consume the item in nextc … until false Is there anything wrong here? Yes, possible race condition!

Semaphores 9 Consider… Shared variables: S = Q = 1; P 0: P 1: wait(S); wait(Q); wait(S); . . . signal(S); signal(Q); signal(S); Is there anything wrong here? Yes, possible deadlock!

Semaphores 10 Consider… P 0: P 1: Enter classroom; Occupy seat; Take exam; Turnoff lights; Is there anything wrong here? Yes, possible indeterminate results! P 2: . . .

Semaphores 11 n A semaphore is a protected variable whose value is accessed and altered by the operations signal (produce) and wait (consume). n n n A semaphore is used for controlling access to a common resource in a concurrent system, such as multi-threading. The value of a semaphore is the number of available resources and may be used to synchronize various task activities. A useful way to think of a semaphore is as a record of how many units of a particular resource are available, coupled with operations to safely consume those units, and, if necessary, wait until a unit of the resource becomes available. 11

Mutexes 12 n A mutex is locking mechanism used to synchronize access to a resource (such as code). n n n Only one task can acquire the mutex. It means there is ownership associated with mutex, and only the owner can release the lock (mutex). A mutex is designed to protect critical data so that only one thread can access it at the same time, such as a section of code or access to a variable. 12

Semaphores 13 n What is a semaphore? n n How are semaphores produced? n n Semaphores are produced by SEM_SIGNAL. How are semaphores consumed? n n A semaphore is an autonomous synchronous abstract data type used for controlling access by multiple processes, to a common resource in a concurrent system. Semaphores are consumed by SEM_WAIT and SEM_TRYLOCK. What are the major uses of semaphores? n n n Synchronization Resource allocation Mutual Exclusion

Semaphores 14 n What does it mean to be autonomous? n n n Disable interrupts (only works on uni-processor) Hardware: test-and-set, exchange Software solutions (Decker) What does it mean to be synchronous? What are the different types of semaphores? n Binary semaphore – 1 resource, 2 states n n n 0 = nothing produced, maybe tasks in queue 1 = something produced, no tasks in queue Counting semaphore – 1 resource, multiple copies n n n 0 = nothing produced, nothing in queue -n = nothing produced, n tasks queued +n = n items produced, no tasks in queue

Semaphores 15 SEM_SIGNAL - Producer void sem. Signal. Binary(Semaphore* semaphore) // signal binary semaphore { semaphore->state = 1; // produce (signal) binary semaphore tid = de. Q(semaphore->queue, -1); // dequeue blocked task if (tid < 0) return; // if empty, return semaphore->state = 0; // blocked task consumes semaphore Produce tcb[tid]. state = S_READY; // ready task for execution en. Q(rq, tid, tcb[tid]. priority); // move task to ready. Consume queue return; void sem. Signal. Counting(Semaphore* semaphore) // signal counting }semaphore // end sem. Signal. Binary { if (++semaphore->state > 0) return; // return if nothing in queue tid = de. Q(semaphore->queue, -1); // dequeue task tcb[tid]. state = S_READY; // ready task for execution en. Q(rq, tid, tcb[tid]. priority); // move task to ready queue Produce & Consume return; } // end sem. Signal. Counting

Semaphores 16 SEM_WAIT - Consumer void sem. Wait. Binary(Semaphore* semaphore) // wait binary semaphore { if (semaphore->state == 0) // signaled? { tcb[cur. Task]. state = S_BLOCKED; // n, change task state to blocked en. Q(semaphore->queue, de. Q(rq, cur. Task)); // move from ready to blocked queue swap. Task(); // reschedule the tasks } semaphore->state = 0; // consume semaphore return; // return w/no block sem. Wait. Counting(Semaphore* semaphore) // wait counting }void // end sem. Wait. Binary semaphore { semaphore->state--; // consume if (semaphore->state < 0) { tcb[cur. Task]. state = S_BLOCKED; // change task state to blocked en. Q(semaphore->queue, de. Q(rq, cur. Task)); // move from ready to blocked quueu swap. Task(); // reschedule the tasks } return; // return w/semaphore

Project 2 Assignment Step 3: 5 -State Scheduling 17 n Add priority queue to semaphore struct n n n // semaphore // link to next semaphore // semaphore name (malloc) // state (count) // type (binary/counting) // tid of creator // blocked queue Malloc semaphore queue in create. Semaphore n n typedef struct semaphore { struct semaphore* sem. Link; char* name; int state; int type; int task. Num; PQueue q; } Semaphore; semaphore->q = (int*)malloc((MAX_TASKS + 1) * sizeof(int)); semaphore->q[0] = 0; // init queue sem. Wait: de. Queue current task from ready queue and en. Queue in semaphore block queue sem. Signal: de. Queue task from semaphore block queue and en. Queue in ready queue.

P 2 - Tasking 5 -State Scheduler create. Task() swap. Task(); sem. Wait(s); sem. Signal(s); sem. Try. Lock(s); dispatch() Ready Queue Running swap. Task() ig m. S se it( ) New SWAP SEM_WAIT(s) SEM_SIGNAL(s) SEM_TRYLOCK(s) Wa #define l() na sem 18 Blocked Queues kill. Task() Exit

Scheduling 19 Task Scheduling Scheduler / Dispatcher Ready Priority Queue Executing SWAP SEM_SIGNAL Semaphore Priority Queue … SEM_WAIT

Project 2 Assignment Step 4 a: Counting Semaphore 20 n Add counting functionality to semaphores n n n Add a 10 second timer (tics 10 sec) counting semaphore to the polling routine (os 345 interrupts. c). n n os 345 semaphores. c: sem. Signal, sem. Wait, sem. Try. Lock Replace goto temp; #include <time. h> header. Call the C function time(time_t *timer). sem. Signal the tics 10 sec semaphore every 10 seconds. Create a reentrant high priority timing task that n n blocks (SEM_WAIT) on the 10 second timer semaphore (tics 10 sec). when activated, outputs a message with the current task number and time and then blocks again.

P 2 - Tasking 21 Task Control Block (tcb) State = { NEW, READY, RUNNING, BLOCKED, EXIT } // task control block Priority = { LOW, MED, HIGH, VERY_HIGH, HIGHEST } typedef struct // task control block { char* name; // task name int (*task)(int, char**); // task address int state; // task state (P 2) int priority; // task priority (P 2) int argc; // task argument count (P 1) char** argv; // task argument pointers (P 1) int signal; // task signals (P 1) // void (*sig. Cont. Handler)(void); // task my. SIGCONT handler void (*sig. Int. Handler)(void); // task my. SIGINT handler // void (*sig. Kill. Handler)(void); // task my. SIGKILL handler // void (*sig. Term. Handler)(void); // task my. SIGTERM handler Pending semaphore when blocked. // void (*sig. Tstp. Handler)(void); // task my. SIGTSTP handler TID parent; // task parent int RPT; // task root page table (P 4) int cdir; // task directory (P 6) Semaphore *event; // blocked task semaphore (P 2) void* stack; // task stack (P 1) jmp_buf context; // task context pointer (P 1) } TCB;

Project 2 Assignment Step 4 b: List Tasks 22 n Modify the list tasks command to n n Display all tasks in all system queues in execution/priority order List task name, if the task is ready, paused, executing, or blocked, and the task priority. If the task is blocked, list the reason for the block. Use the project 2 command to schedule timer tasks 1 through 9, 2 signal tasks and 2 “Im. Alive” tasks. n n n The tics 10 sec task about the current time every 10 seconds in a round robin order. (Round Robin) The “Im. Alive” tasks will periodically say hello. (Blocking) The high priority “Signal” tasks should respond immediately when semaphore signaled. (Priority)

Project 2 Assignment Step 4 c: Verification 23 Demo n # Task Name Priority Time slice Blocking Semaphore 0 CLI w/pseudo-input interrupts 5 1 in. Buffer. Ready 1 -9 Ten. Seconds 10 1 tics 10 sec 10 s. Task 1 20 1 s. Task 10 11 s. Task 2 20 1 s. Task 11 12 Im. Alive 1 1 None 13 Im. Alive 1 1 None

24