Cs 704 d set3

CS 704DAdvanced Operating SystemDebasis Das

Tools for Implementationof Semaphores #3Compare & Swap InstructionsHelps consistent update of global variableImplementationCompare Oldreg, GlobvarSet condition codesIf (Oldreg=Globvar) Then Globvar Newreg Else OldregGlobvarMIT CS704D Advanced OS Class of 20112

Queuing Implementationof SemaphoreMIT CS704D Advanced OS Class of 20113SemaphorePz…..PyPxWait(s): If not (s>0) then suspend caller at s else s:= s+1Signal (s): if queue is not empty (at least one process is waiting) then resume process from the queue at s else s:=s+1

Overview of Classical Synchronization problemsProducers and consumersWith unbounded buffersWith bounded buffersReaders and writersMIT CS704D Advanced OS Class of 20114

Producers & ConsumersOne class of processes produce data itemsThe other class consumes/uses this dataThey may have different rates and thus cause synchronization problemsSynchronizations required so that producers & consumers are able to operate concurrentlySuch that items produced are consumed in the same orderDisplay, keyboard was an exampleProcesses may be a combination of both producer and consumerMIT CS704D Advanced OS Class of 20115

Producers & Consumers(unbounded buffer case)If we can prevent a process trying to consume something before at least one item is available, sync is achievedA semaphore “Producer” can take care of thatWe assume buffer manipulation does not cause problemsThis is not really a valid assumption in multiple producer, consumer situationsMIT CS704D Advanced OS Class of 20116

Unbounded Buffer CaseA mutex controlling buffer access can manage the situation wellHow the mutex is used exactly can have unintended implicationsIf the waiting on “producer” is placed within the critical section, there can be deadlocksInitially, for example, when nothing has been produced and a consumer is scheduled, the consumer will get through to the critical sectionThen wait forever on Producer as a producer process cannot get into the critical sectionMIT CS704D Advanced OS Class of 20117

Producers & Consumers(bounded buffer case)Additional management issues are that the buffers are to be controlledProducers should not produce when buffer is full, it will overwrite some existing dataConsumers, similarly will consume wrong data if buffer is emptyThese conditions have to be controlledMIT CS704D Advanced OS Class of 20118

Unbounded case Icount=produced-consumedNecessary that icount cannot be less than zero and more than the capacityThenCondition mayproduce : icount < capacity as also mayconsume: icount>0MIT CS704D Advanced OS Class of 20119

Readers & WritersReaders and consumers are processes that operate against some common data structureReaders are pure readers, only reads parts or all of the data structureWriters write and thus modify the data structure. It can also read the structure or parts of itReaders thus can safely get interleaved with other readersBut writes cannot be interleaved with other readers or writersMIT CS704D Advanced OS Class of 201110

The sync ProblemGiven a universe of readers that read a common data structure, and a universe of writers that modify the same common data structureA sync mechanism needs to be devised to control readers and writers to ensure consistency of common data and maintain as high a concurrency as possibleMIT CS704D Advanced OS Class of 201111

Example SynchronizationHigh concurrencyAllows high number of readers to access common resourceWriter waits for the wait semaphoreReader process makes it possible for multiple readers to workReadercount really tracks if even one reader is activeNext round, the writer gets turn only when all readers finished reading, that may be unfairMIT CS704D Advanced OS Class of 201112

Suggested Modifications(according to C A R Hoare)A reader should not start if there’s a writer waiting, preventing starvation for writersAll readers waiting at the end of a write cycle should be given priority, preventing starvation of readersMIT CS704D Advanced OS Class of 201113

Inter-process Communication& SynchronizationMIT CS704D Advanced OS Class of 201114

Semaphore ProblemsSync and system integration depend on strict following of the discipline and implementation. Forgetting of either of wait and signal mechanism, reversing or going around it will cause problems in the systemSemaphores control access to shared resources but cannot prevent misuse of the same by some process granted access to these global variables.MIT CS704D Advanced OS Class of 201115

Critical Regions & Conditional critical RegionsStrong typing and compile time checks can prevent some of the problemsFor example var mutex : shared T; and critical section as follows region mutex doThe compiler can ensure wait and signals are introduced properly, no probability of errorsMIT CS704D Advanced OS Class of 201116

Why condionality requiredSometimes a process getting access to the CS may still need some condition to be fulfilled and thus block other processing entering the CSConditional CS construct can prevent such problemsMIT CS704D Advanced OS Class of 201117

Conditional Critical Regionvar mutex: shared T;begin region v dobeginawait conditionend;End;Special queue is maintained, allowed only when the condition is metMIT CS704D Advanced OS Class of 201118

MonitorMIT CS704D Advanced OS Class of 201119Enforce concurrencyProcessesProcessesAccess, modify shared variable(s)

Monitors-Plus MinusCan regulate a group of related resources tooIf this is too many, the serialization overhead could be too muchSame things can be done at kernel levelSerialization overheads will cause problems very quickly as kernel controls all kinds of resourcesWriting, building, debugging such monolithic structures could be problematicMonitors can create a deadlockMonitor disciplines may restrict application programmersMIT CS704D Advanced OS Class of 201120

MessagesA collection of data, execution commands, sometimes even codeInterchanged between sending and receiving processesMIT CS704D Advanced OS Class of 201121Sender idReceiver idLengthHeaderType……Message body

Issues in Message ImplementationNamingDirect, indirect (mailbox)CopyingCopy message, pass pointerSynchronous/asynchronousSynchronous can be blocking, asynchronous can cause runaway, indefinite postponementLengthFixed or variable length (overhead vs. flexibility)MIT CS704D Advanced OS Class of 201122

Inter-process Communication & sync with MessagesAssume buffered message, infinite channel capacity, indirect naming (via mailboxes)Sender send s the message & continues, receiver will be suspended if no messageSync through semaphore like operation of messages. Signal send a message to waiting on semaphore, wait is just waiting to receive a messageSync also can be through messagesExample; producer waits for a message through mayproduce mailbox, a consumer gets a mayconsumeMIT CS704D Advanced OS Class of 201123

Interrupt Signaling via MessageA message (signal) can initiate a set of waiting interrupt service processesInterrupt service need not be treated differently from other processesHardware interrupts that need guaranteed response time, may be a problemAll software interrupts can be handled this wayMIT CS704D Advanced OS Class of 201124

DeadlocksA deadlock is a situation where processes are permanently blocked as a result of each process having acquired a subset of the resources needed for its completion and waiting for the release of the remaining resources held by others in the same group- thus making it impossible for any of the processes to proceed.MIT CS704D Advanced OS Class of 201125

Necessary ConditionsMutual exclusion. Shared resources are used exclusively by at most one process at a time.Hold & Wait. Resources already allocated are held by the process and waits for the balance to be acquiredNo preemption. Resources are released only when given up by the ownerCircular waiting. Each process hold one or more resources being requested by the next process in the chainMIT CS704D Advanced OS Class of 201126

Reusable & Consumable ResourcesReusable. Resources that can be safely used by one process at any time.It is either available or allocated to a processIt can only be relinquished by the ownerSingle resource multiple instances, multiple resources of single instanceConsumable resources. Once consumed, these do not exist any more; example messages. Deadlocks can happen, such as a receiver waiting for a message. OS must intervene to break such deadlocks.MIT CS704D Advanced OS Class of 201127

Deadlock Prevention-1Hold-an-wait condition can be resolved by forcing release of all other held resources when the process requests for a resource that is not available.Request all resources prior to executionAsks for resources as needed but relinquishes resources held by it when a requested resource is not availableOverestimation of resources, holding on to resources longer than necessaryReduces concurrency, resources are underutilizedMIT CS704D Advanced OS Class of 201128

Deadlock Prevention-2No-preemptionissue can obviously be solved by allowing preemptionOS will need to save the state of the processFor some resources the preemption may not be a problem, like CPU and memory pages but resources like files cannot be safely preempted without corrupting the systemApply such policies only when the benefits of deadlock prevention is more than the cost of save & restore of state of some resourcesMIT CS704D Advanced OS Class of 201129

Deadlock Prevention-3Circular wait. Request resources of a higher class only after the resources from a lower class has been acquired successfully. All requests in a given class must be acquired through a single request.The prescribed ordering can be checked at compile time, avoiding run time problemsDisadvantagesAll resources must be acquired up frontLower degree of concurrency and lower utilization of resourcesMIT CS704D Advanced OS Class of 201130

Deadlock AvoidanceGrant resources only if the request is not likely to cause deadlocksA resource allocator must examine the implicationsAll processes must proclaim maximum needWhen requested, the resource allocator must check if the other executing processes can safely complete (they have resource allocation pending) . If not the process should wait.MIT CS704D Advanced OS Class of 201131

Deadlock detection & RecoveryIf the general resource graph has a cycle or a knot then deadlock existsRollback or restarting can be optionsState needs to be knownSome systems have check pointing or journaling system, one could use thatMIT CS704D Advanced OS Class of 201132

Combined ApproachTypical classes of devicesSwap areaJob resources & assignable devicesMain memory (by page, segment etc.)Internal resources such as I/O channels, buffer pool etc.Deadlock prevention between the main classes, deadlock handling within each class is usedMIT CS704D Advanced OS Class of 201133

Combined PoliciesSwap space: advance booking of all swap space. Dead lock detection is not possibleJob resources: pre-claiming of resources, Resource ordering also is possible. Detection combined with recovery is undesirable, as can have repercussions on file resourcesMain memory : preemption is used but not avoidance as that has run time overheads and resource underutilizationInternal system resources : avoidance or detection will have performance penalties. Prevention by means of resource ordering is typically doneMIT CS704D Advanced OS Class of 201134

Cs 704 d set3

More Related Content

Viewers also liked (14)

Similar to Cs 704 d set3 (20)

More from Debasis Das (15)

Recently uploaded (20)

Cs 704 d set3