Lecture Outline

Aims and Objectives
Issues
Clock Synchronisation
Mutual Exclusion
Election Algorithms
Atomic Transactions
Implementing Transaction Processing: Two Methods
Committing Transactions
Concurrency Control
Deadlock

• Issues

• Clock Synchronisation

• Mutual Exclusion

• Choosing a Leader

• Transaction Processing

• Deadlock

• How do processes cooperate and synchronise with each other?

  Each computer's internal clock can be different

  No shared memory to synchronise on semaphores

  Delay in data communications

  Detecting computer/process crashes

• How are critical regions implemented?

  When the processes are located on different computers

• How are resources allocated?

  When processes on different computers require the same resource

  Deadlock

• Synchronising processes in a distributed environment is difficult because:

  relevant information can be anywhere on the system

  processes can make decisions based only on local information

  want to avoid having a centralised coordinator

  no shared system clock

Logical Clocks

• Not always necessary for each computer to know the exact time

• Sufficient for computers to know the order in which events occur

• Computers can update their logical clocks based on when events occurred on cooperating computers

  

• Additionally, between two events the clock must tick at least once

Physical Clocks

• Some processes are dependent on real time.

• The problems are to synchronise physical clocks with real-world clocks and to synchronise physical clocks

• Universal Coordinated Time

  Atomic Clocks are used to keep accurate track of time. The National Institute of Standard Time broadcasts using the call sign WWV on SW Radio and computers can receive this (expensive)

Synchronising Physical Clocks

• Time server connected to WWV receiver

• Computers ask the time server for the current time, and reset their clocks

• Problems

  Time is not allowed to run backwards - client must "slow down" time if its clock is running fast

  The time taken for the server to send the response and the client to receive it (and generate an interrupt, etc.) takes... a variable amount of time! Depends on network load, etc.

  Client can ask server for time repeatedly and calculate average delay and take this into account when resetting its clock

What if you have no access to a WWV receiver?

• The Berkeley Algorithm

  A time daemon periodically asks all computers what time they think it is and computed the average time

  Tells other computers the computed average time

• To ensure that no two processes can use exactly the same shared data structure at the same time, by allowing only one process at a time to be in a critical section

A Token Ring Algorithm

• E.g., for a bus network

• All processes are arranged into a logical ring (i.e., each process knows who its neighbours are)

• When the system is started up, process 0 is given a token

• It checks if it wants to enter a critical section

  if yes: enter critical section. On exit pass token to Process 1

  if no: pass token to process 1

• Processes are not allowed to enter a critical section if they do not have a token

• Processes must pass on the token as soon as they have exited a critical section

• What happens if token is lost? if a process crashes?

• It is sometimes necessary for a process to be elected a coordinator

• Although this means that coordination is centralised, it is sometimes needed for efficiency

• Doesn't matter which process is coordinator. Important that if the coordinator dies, another coordinator is elected, rather than the system halting

Bully Algorithm

• Assumes that processes are uniquely identifiable, each process knows the ids of all other processes

• What isn't known is whether a process is dead or alive

• Assume that a previously elected coordinator is no longer responding to requests

  The first process to notice sends an ELECTION message to all processes with ids higher than itself

  If no process responds, the process wins the election and informs all processes that it is coordinator with immediate effect

  If a process receives an ELECTION message is sends OK to the sender and holds and election

  Eventually, all processes but one will have surrendered the election

  The victor announces its victory

• Whenever a machine restarts, it holds an election. If it has the highest id it will win, hence the name of the algorithm

• Similar to transaction processing in databases (becauses databases are usually shared - and processes need to be monitored to ensure that the same table isn't updated in the wrong order)

• Properties of transactions

  Atomic - either all steps in the transaction are completed, or none are

  Consistent - the transaction does not violate system invariants (e.g., bank's law of conservation of money)

  Isolated - concurrent transactions do not interfere with each other (the transactions are serialisable)

  Durable - once a transaction commits, the changes are permanent

• Transactions need some kind of private workspace - to hide intermediate changes from the rest of the world, and to support nested transactions, where the inner transactions are committed but will need to be undone if the parent (outer) transaction fails.

Private Workspace

• File is copied to private workspace only if process will modify file

• Initially, only file's index blocks are copied to workspace

• If data blocks need to be modified, the individual blocks are copied to the private workspace (shadow blocks). New blocks are written to private workspace

• If transaction aborts, private workspace is deleted

• If transaction commits, index blocks in the private workspace are moved into the parent's workspace

Writeahead Log

• Transactions are recorded in a shared intentions list.

• Files are modified in place

• If the transaction is completed the changes are committed

• If the transaction aborts, the logs is used to rollback to the original state

• Logs can also be used to recover from crashes, roll forward

Two-phase Commit Protocol

• A process (usually the function executing the transaction) acts as a coordinator

• Coordinator writes a "prepare to commit" message in the log to start the protocol

• Sends a message to each subordinate process involved

• If subordinate is ready to commit, it writes to the log and sends the coordinator a message

• When coordinator has received "ready" messages from all subordinates, the transaction is committed

• If one or more subordinates cannot commit or do not reply, the transaction is aborted

Locking

Optimistic concurrency Control

Timestamps

• Strategies

  Ostrich

  Detection and Recovery

  Prevention

• Avoidance is never used in distributed systems

Deadlock Detection and Recovery

• Transactions are designed to withstand being aborted, so recovery from deadlock is straightforward

• Simply kill the deadlocked processes and roll them forward

• Detecting deadlock

  Chandry-Misra-Haas (1987) algorithm is commonly used

  Processes are allowed to request and wait on several resources simultaneously

  

  Algorithm invoked when a process is waiting on a resource

  A probe message is sent to the process holding the resource

  Message consists of blocked process number, process number of sender, process number of process holding the resource

  Recipient checks if it is blocked waiting for a resource

  If yes, updates message and forwards it

  If message ultimately returns to first blocked process, deadlock exists

Deadlock Prevention

• Deny circular-waiting

  Processes are timestamped

  If an older process wants a resource held by a younger process, wait

  If a younger process wants a resource held by an older process, the younger process dies

  ... The wait-die algorithm

• Alternatively, kill transaction in which resource is used - pre-emption. Killed transaction simply rolls forward when restarted

Next Lecture....

Processes and Processors in Distributed Operating Sytems