Module – 1 Lesson Plan

▪ L1: Distributed System – Definition, Relation to computer system components

▪ L2: Primitives for distributed communication

▪ L3: Design issues, challenges and applications.

▪ L4: Design issues, challenges and applications.

▪ L5: A model of distributed computations – Distributed program, Model of distributed executions

▪ L6: Models of communication networks, Global state of a distributed

▪ L7: Cuts of a distributed computation, Past and future cones of an event, Models of process
communications.

Distributed Systems
▪ A distributed system is a collection of independent entities that cooperate
to solve a problem that cannot be individually solved.

▪ Collection of independent systems that work together to solve a problem

or to accomplish a task.

▪ Distributed Computing is a model in which multiple computers (nodes)

work together to solve a single problem or provide a service.

▪ These nodes communicate through a network and appear to the user as a

single, unified system.
 Distributed Systems
Distributed system has been characterized in one of several ways:
1. You know you are using one when the crash of a computer you have never heard of prevents you from
doing work-Example: Google Search
• Google search uses thousands of [Link] type a query → it is processed by several [Link] one of
those unknown machines fails:
• Your search may become [Link] may not work for a few seconds
• Even though you don’t know which machine failed, you are affected.
2. A collection of computers that do not share common memory or a common physical clock, that
communicate by a messages passing over a communication network, and where each computer has its own
memory and runs its own operating system.

3.A collection of independent computers that appears to the users of the system as a single coherent computer.

4.A term that describes a wide range of computers, from weakly coupled systems such as wide-area networks,
to strongly coupled systems such as local area networks, to very strongly coupled systems such as
multiprocessor systems.

Features of Distributed Systems

▪ No common physical clock-Each processor (computer) in a distributed system has its
own clock. They are not synchronized automatically. Each clock runs at slightly
different speeds. This creates asynchrony → processors do not know the exact time on
each other’s machines. Timing-based coordination becomes difficult.

▪ No shared memory -Processors cannot directly access each other’s memory. Unlike
multi-core processors on one motherboard, distributed nodes are separate computers.

• Geographical separation -Distributed systems may have processors located:

• in the same building, in the same room, in different states, across different countries.
Even processors connected within a LAN can form a distributed system.
 Features of Distributed Systems
Autonomy and heterogeneity:

• Autonomous processors = independent computers. Each processor (node):

• has its own CPU
• has its own memory
• runs its own operating system
• can work independently
Heterogeneous = not all machines are the same.
• Machines in a distributed system may vary in:hardware (Intel, AMD, ARM processors)
memory size,speed,operating system (Windows, Linux, macOS, Unix),software versions
• Yet they can still communicate and work together.

Relation to computer system components

1. Many independent computers (nodes) :A distributed system connects processors by a communication network.”
Each small box labeled P M represents:
P → Processor (CPU)
M → Memory (local RAM) :
So each node has its own processor and its own memory.

[Link] Network (WAN/LAN)

All nodes are connected to a network, which may be:
Local Area Network (LAN) — inside a building, lab, data center
Wide Area Network (WAN) — distributed across cities or countries

3. Message Passing
Because each system has its own memory, they can communicate only by sending messages through the network.
 Relation to computer system components
• It explains how software is layered inside each node (computer)
in a distributed system.

Each processor has:

• Distributed Application (top-level program)
• Distributed Software (Middleware) → connects apps across nodes
• Operating System
• Network Protocol Stack (Data link → Network → Transport → Application layers)

When a distributed application communicates with another node:

• Application makes a request to middleware
• Middleware converts request to messages
• OS passes message to protocol stack
• Data travels through network layers (transport → network → link)
• Message reaches another node
• Middleware on the other node decodes it
• Application receives the result

Relation to computer system components

▪ Each computer has a memory-processing unit and the computers are connected by a
communication network.
▪ The distributed software is also termed as middleware. A distributed execution is the execution
of processes across the distributed system to collaboratively achieve a common goal.
▪ The distributed system uses a layered architecture to break down the complexity of system
design.
▪ The middleware is the distributed software that drives the distributed system, while providing
transparency of heterogeneity.
▪ Middleware ≠ Traditional application layer protocols (like HTTP, mail, FTP, telnet.).
Middleware is for distributed communication and coordination.
 Relation to computer system components
Standards that support middleware
Well-known standards for distributed interaction:
✔ CORBA
Common Object Request Broker Architecture
Allows objects on different machines to communicate

✔ RPC – Remote Procedure Call

Works like a normal function call,But the function might be on another machine
RPC software sends a message → waits for reply → returns result
To the programmer it looks like a normal local call

✔ DCOM, Java RMI

Used in commercial distributed systems.

✔ MPI
Message Passing Interface
Used in scientific computing and supercomputers
Provides functions for sending/receiving messages efficiently

Tutorial 1
• Compare distributed computing and parallel multiprocessor/
multicomputer systems.
• Identify Flynn’s taxonomy of four processing modes
• Coupling, parallelism, concurrency, and granularity
• Message-passing systems versus shared memory systems
Motivation For Distributed Systems
(Advantages)
▪ Inherently distributed computations : In many applications such as money transfer in
banking, or reaching consensus among parties that are geographically distant, the
computation is inherently distributed
▪ Resource sharing
▪ Access to geographically remote data and resources
▪ Enhanced reliability
Reliability entails several aspects: availability, integrity, fault-tolerance
▪ Increased performance/cost ratio : By resource sharing and accessing geographically
remote data and resources, the performance/cost ratio is increased
▪ Scalability
▪ Modularity and incremental expandability

Primitives for distributed communication

Blocking/non-blocking, synchronous/asynchronous primitives

▪ Send() and Receive() primitives are used to send and receive messages
▪ A Send primitive has at least two parameters – the destination, and the buffer
in the user space, containing the data to be sent
▪ Receive primitive has at least two parameters –source from which the data is
to be received, and the user buffer into which the data is to be received.

▪ There are two ways of sending data when the Send primitive is invoked –
1. the buffered option
2. the unbuffered option.
 Primitives for distributed communication
There are two ways of sending data when the Send primitive is invoked the
buffered option and the unbuffered option.
• The buffered option which is the standard option copies the data from the user
buffer to the kernel buffer.
• The data later gets copied from the kernel buffer onto the network.
• In the unbuffered option, the data gets copied directly from the user buffer
onto the network.
• For the Receive primitive, the buffered option is usually required because the
data may already have arrived when the primitive is invoked, and needs a
storage place in the kernel.

Primitives for distributed communication

Synchronous primitives
A Send or a Receive primitive is synchronous if both the Send() and Receive() handshake with each other.
The processing for the Send primitive completes only after the invoking processor learns that the other
corresponding Receive primitive has also been invoked and that the receive operation has been
completed.
Asynchronous primitives
A Send primitive is said to be asynchronous if control returns back to the invoking process after the data
item to be sent has been copied out of the user-specified buffer.
 Primitives for distributed communication
Why asynchronous Receive() does NOT make sense?

Primitives for distributed communication

Blocking primitives : A primitive is blocking if control returns to the invoking process after
the processing for the primitive (whether in synchronous or asynchronous mode)
completes.
Blocking Synchronous Send
The send operation is synchronous → it requires a handshake with the receiver.
It is also blocking → control returns to sender only after the matching Receive has been
invoked and completed. Sender is blocked until the receiver actually gets the message
Blocking Asynchronous Send
The send operation is asynchronous → Send does not wait for receiver; it returns after
copying data out of the user [Link] does not wait for the receiver to invoke Receive. No
need for receiver to be ready. It is called blocking because the sender process blocks
(waits) until its own send operation completes. the sender is blocked only until the copy
[Link] sender is not blocked waiting for the receiver.
Blocking Receive -Blocking Receiver waits until the message arrives; control returns only
after the message is received.
 Primitives for distributed communication

Non-blocking primitives
A primitive is non-blocking if control returns back to the invoking process immediately
after invocation, even though the operation has not completed.
Non Blocking Send : Continues after sending message
Non Blocking Receiver : Continues even if message is received or not

Primitives for distributed communication

Processor synchrony :
▪ Processor synchrony indicates that all the processors execute in lockstep
with their clocks synchronized.
▪ As this synchrony is not attainable in a distributed system, what is more
generally indicated is that for a large granularity of code, usually termed as
a step, the processors are synchronized.
▪ This abstraction is implemented using some form of barrier
synchronization to ensure that no processor begins executing the next step
of code until all the processors have completed executing the previous
steps of code assigned to each of the processors.
 Design issues and challenges
The following functions must be addressed when designing and building a distributed system:
1. Communication
2. Processes
3. Naming
4. Synchronization
5. Data storage and access
6. Consistency and replication
7. Fault tolerance
8. Security
9. Applications Programming Interface (API) and transparency
10. Scalability and modularity

Design issues and challenges

Distributed systems challenges from a system perspective
1. Communication
This task involves designing appropriate mechanisms for communication among the
processes in the network. Some example mechanisms are:
remote procedure call (RPC), remote object invocation (ROI), message-oriented
communication versus stream-oriented communication.

2. Processes
Some of the issues involved are: management of processes and threads at clients/servers;
code migration; and the design of software and mobile agents.

3. Naming
Devising easy to use and robust schemes for names, identifiers, and addresses is
essential for locating resources and processes in a transparent and scalable manner.
 Design issues and challenges
Distributed systems challenges from a system perspective
4. Synchronization Mechanisms
Synchronization or coordination among the processes are essential. Mutual exclusion is
the classical example of [Link] addition, synchronizing physical clocks, and
devising logical clocks that capture the essence of the passage of time, as well as global
state recording algorithms, all require different forms of synchronization.

5. Data storage and access

Schemes for data storage, and implicitly for accessing the data in a fast and scalable
manner across the network are important for efficiency. Traditional issues such as file
system design have to be reconsidered in the setting of a distributed system.

Design issues and challenges

6. Consistency and replication
To avoid bottlenecks, to provide fast access to data, and to provide scalability,
replication of data objects is highly desirable. This leads to issues of managing the
replicas, and dealing with consistency among the replicas/caches in a distributed
setting.
7. Fault tolerance
Fault tolerance requires maintaining correct and efficient operation in spite of any
failures of links, nodes, and processes. Process resilience, reliable communication,
distributed commit, checkpointing and recovery, agreement and consensus, failure
detection, and self-stabilization are some of the mechanisms to provide fault-tolerance.
8. Security
Distributed systems security involves various aspects of cryptography, secure channels,
access control, key management – generation and distribution, authorization, and
secure group management.
 Design issues and challenges
9. Applications Programming Interface (API) and transparency
The API for communication and other specialized services is important for the ease of use and wider
adoption of the distributed systems services by non-technical users.
Transparency deals with hiding the implementation policies from the user, and can be classified as follows
▪ Access transparency hides differences in data representation on different systems and provides uniform
operations to access system resources.
▪ Location transparency makes the locations of resources transparent to the users.
▪ Migration transparency allows relocating resources without changing names.
▪ Relocation transparency: The ability to relocate the resources as they are being accessed is.
▪ Replication transparency does not let the user become aware of any replication.
▪ Concurrency transparency deals with masking the concurrent use of shared resources for the user.
▪ Failure transparency refers to the system being reliable and fault-tolerant.

Design issues and challenges

10. Scalability and modularity
The algorithms, data (objects), and services must be as distributed as possible.
Various techniques such as replication, caching and cache management, and asynchronous processing help
to achieve scalability.
 Design issues and challenges
Algorithmic challenges in distributed computing
▪ Designing useful execution models and frameworks

▪ Dynamic distributed graph algorithms and distributed routing algorithms

▪ Time and global state in a distributed system

▪ Synchronization/coordination mechanisms

▪ Group communication, multicast, and ordered message delivery

▪ Monitoring distributed events and predicates

▪ Distributed program design and verification tools

▪ Debugging distributed programs

▪ Data replication, consistency models, and caching

Design issues and challenges

Algorithmic challenges in distributed computing
1. Designing useful execution models and frameworks

The interleaving model and partial order model are two widely adopted models of distributed system
executions. They have proved to be particularly useful for operational reasoning and the design of
distributed algorithms.

2. Dynamic distributed graph algorithms and distributed routing algorithms

The distributed system is modelled as a distributed graph, and the graph algorithms form the building
blocks for a large number of higher level communication, data dissemination, object location, and object
search functions. The algorithms need to deal with dynamically changing graph characteristics, such as
to model varying link loads in a routing algorithm. The efficiency of these algorithms impacts not only
the user-perceived latency but also the traffic and hence the load or congestion in the network.
 Design issues and challenges
Algorithmic challenges in distributed computing
3. Time and global state in a distributed system
The challenges pertain to providing accurate physical time, and to providing a variant of time, called logical
time .Logical time is relative time, and eliminates the overheads of providing physical time for applications
where physical time is not required. Observing the global state of the system (across space) also involves the
time dimension for consistent observation. Deriving appropriate measures of concurrency also involves the
time dimension.

4. Synchronization/coordination mechanisms
Synchronization is essential for the distributed processes to overcome the limited observation of the system
state from the viewpoint of any one process.
Overcoming this limited observation is necessary for taking any actions that would impact other processes. .
The synchronization mechanisms can also be viewed as resource management and concurrency management
mechanisms.

Design issues and challenges

Algorithmic challenges in distributed computing
Problems Requiring Synchronization
▪ Physical clock synchronization
▪ Leader election - All the processes need to agree on which process will play the role of a distinguished process
– called a leader process.
▪ Mutual exclusion
▪ Deadlock detection and resolution
▪ Termination detection
▪ Garbage collection - refers to objects that are no longer in use and that are not pointed to by any other
process. Detecting garbage requires coordination among the processes
5. Group communication, multicast, and ordered message delivery
A group is a collection of processes that share a common context and collaborate on a common task within an
application domain. Specific algorithms need to be designed to enable efficient group communication and group
management wherein processes can join and leave groups dynamically, or even fail. When multiple processes
send messages concurrently, different recipients may receive the messages in different orders, possibly violating
the semantics of the distributed program. Hence, formal specifications of the semantics of ordered delivery need
to be formulated, and then implemented.
 Design issues and challenges
Algorithmic challenges in distributed computing
[Link] distributed events and predicates
Predicates defined on program variables that are local to different processes are used for specifying conditions
on the global system state, and are useful for applications such as debugging, sensing the environment, and in
industrial process control. On-line algorithms for monitoring such predicates are hence important. An
important paradigm for monitoring distributed events is that of event streaming, wherein streams of relevant
events reported from different processes are examined collectively to detect predicates.
[Link] program design and verification tools
Methodically designed and verifiably correct programs can greatly reduce the overhead of software design,
debugging, and engineering. Designing mecha nisms to achieve these design and verification goals is a
challenge.
[Link] distributed programs
Debugging sequential programs is hard; debugging distributed programs is that much harder because of the
concurrency in actions and the ensuing uncertainty due to the large number of possible executions defined by
the interleaved concurrent actions. Adequate debugging mechanisms and tools need to be designed to meet
this challenge.

Design issues and challenges

Algorithmic challenges in distributed computing
[Link] replication, consistency models, and caching
Fast access to data and other resources requires them to be replicated in the distributed
system. Managing such replicas in the face of updates introduces the problems of ensuring
consistency among the replicas and cached copies. Additionally, placement of the replicas in
the systems is also a challenge because resources usually cannot be freely replicated.
 Applications of distributed computing and newer challenges
1. Mobile systems

2. Sensor networks

3. Ubiquitous or pervasive computing

4. Peer-to-peer computing

5. Publish-subscribe, content distribution, and multimedia

6. Distributed agents

7. Distributed data mining

8. Grid computing

9. Security in distributed system

Applications of distributed computing

and newer challenges
1. Mobile systems

Mobile systems typically use wireless communication which is based on electromagnetic waves and
utilizes a shared broadcast medium.

the characteristics of communication are different;

set of problems such as

i. routing,

ii. location management,

iii. channel allocation,

iv. localization and position estimation,

v. the overall management of mobility

 Applications of distributed computing
and newer challenges
There are two popular architectures for a mobile network.

1. base-station approach,

also known as the cellular approach, wherein a cell which is the geographical region within range of a static
but powerful base transmission station is associated with that base station

2. ad-hoc network approach where there is no base station

All responsibility for communication is distributed among the mobile nodes, wherein mobile nodes have to
participate in routing by forwarding packets of other pairs of communicating nodes

Applications of distributed computing

and newer challenges
2. Sensor networks

A sensor is a processor with an electro-mechanical interface that is capable of sensing physical parameters,
such as temperature, velocity, pressure, humidity, and chemicals Sensors may be mobile or static;

sensors may communicate wirelessly, although they may also communicate across a wire when they are
statically installed.

3. Ubiquitous or pervasive computing

The intelligent home, and the smart workplace are some example of ubiquitous environments Ubiquitous
systems are essentially distributed systems;

recent advances in technology allow them to leverage wireless communication and sensor and actuator
mechanisms
 Applications of distributed computing
and newer challenges
4. Peer-to-peer computing

• Peer-to-peer (P2P) computing represents computing over an application layer network wherein all
interactions among the processors are at a “peer” level, without any hierarchy among the processors.

• P2P computing arose as a paradigm shift from client–server computing where the roles among the
processors are essentially asymmetrical.

• P2P networks are typically self-organizing, and may or may not have a regular structure to the
network.

5. Publish-subscribe, content distribution, and multimedia

In a dynamic environment where the information constantly fluctuates

there needs to be:

Applications of distributed computing

and newer challenges
i. an efficient mechanism for distributing this information (publish),

ii. an efficient mechanism to allow end users to indicate interest in receiving specific kinds of
information (subscribe),

iii. an efficient mechanism for aggregating large volumes of published information and
filtering it as per the user’s subscription filter

6. Distributed agents

Agents collect and process information, and can exchange such information with other agents

Challenges in distributed agent systems include coordination mechanisms among the agents,
controlling the mobility of the agents, and their software design and interfaces.
 Applications of distributed computing
and newer challenges
7. Distributed data mining

The data is necessarily distributed and cannot be collected in a single repository, massive to collect and
process at a single repository in real-time.

8. Grid computing

Grid Computing is a subset of distributed computing, where a virtual supercomputer comprises machines
on a network connected by some bus, mostly Ethernet or sometimes the Internet.

idle CPU cycles of machines connected to the network will be available to others

9. Security in distributed systems

The traditional challenges of security in a distributed setting include:

Applications of distributed computing

and newer challenges
confidentiality (ensuring that only authorized processes can access certain information),

authentication (ensuring the source of received information and the identity of the sending process),

availability (maintaining allowed access to services despite malicious actions).

 A model of distributed computations
✔ A distributed system consists of a set of processors that are connected by a communication network.

✔ The communication network provides the facility of information exchange among processors.

✔ The processors do not share a common global memory and communicate solely by passing messages over
the communication network.

A distributed program :

▪ A distributed program is composed of a set of n asynchronous processes p1, p2, , pi, , pn

that communicate by message passing over the communication network.
▪ Without loss of generality, we assume that each process is running on a different
processor.
▪ The processes do not share a global memory and communicate solely by passing
messages.

A model of distributed computations

▪ The global state of a distributed computation is composed of the states of the processes and the
communication channels. The state of a process is characterized by the state of its local memory and
depends upon the context. The state of a channel is characterized by the set of messages in transit in the
[Link] execution and message transfer are asynchronous.

▪ The message transmission delay is finite and unpredictable.

A model of distributed executions

The execution of a process consists of a sequential execution of its actions. The actions are atomic and the
actions of a process are modelled as three types of events,

1. internal events

[Link] send events

[Link] receive events

 A model of distributed computations

A model of distributed computations

 A model of distributed computations
•

A model of distributed computations

 A model of distributed computations
• What is Causal Precedence (→)?
• Causal precedence means:
• One event can influence another event
(directly or indirectly)
• It is the formal way of saying “this event happened before that event and could have affected it.”
• This is exactly Lamport’s “happens-before” relation.
• The Causal Precedence relation is related to the happened-before relation in message-based
communication.
• Lamport refers to Leslie Lamport, a renowned computer scientist who made foundational
contributions to distributed systems, concurrency, and formal methods.
Who is Leslie Lamport?
• An American computer scientist
• Winner of the Turing Award (2013) 🏆
• Known for:
• Lamport’s logical clocks
• Happens-before relation
• LaTeX document preparation system

A model of distributed computations

The Causal Precedence relation is related to the happened-before relation in message-based

communication.
 A model of distributed computations
•

A model of distributed computations

•
 A model of distributed computations
•

A model of distributed computations

•
A model of distributed computations

A model of distributed computations

• If swapping the order of two events does not change the program’s
result, then those events are logically concurrent.

MODELS OF COMMUNICATION NETWORKS

• When processes communicate by sending messages, the order in
which messages are delivered matters. Different systems provide
different ordering guarantees.
• The three main models are:
• Non-FIFO ordering
• FIFO ordering
• Causal ordering
 MODELS OF COMMUNICATION NETWORKS
• Non-FIFO Message Ordering (Weakest)
• Messages can be delivered in any order, No guarantees at all. In the non-FIFO model, a channel
acts like a set in which the sender process adds messages and the receiver process removes
messages from it in a random order.
• A communication channel behaves like a set, not a queue.
Process P₁ sends two messages to P₂:
• send(m1)
• send(m2)
Possible delivery at P₂:
• receive(m2)
• receive(m1)
Problem
• Sender order is not preserved
• Very hard to design correct distributed algorithms

MODELS OF COMMUNICATION NETWORKS

FIFO Message Ordering (Stronger)
• Definition
• Messages sent from the same sender to the same receiver are delivered in
the same order
• Each channel behaves like a queue (FIFO).
Process P₁ → P₂:
send(m1)
send(m2)
Guaranteed delivery at P₂:
receive(m1)
receive(m2) - Order preserved for one sender–receiver pair
FIFO does not consider causality across different senders.
MODELS OF COMMUNICATION NETWORKS
• Causal Message Ordering (Strongest & Most useful)
• Messages are delivered in an order that respects causality.
• If sending message m₁ causally happens before sending message m₂,
then all receivers must receive m₁ before m₂.

• If:
• Message m₁ is sent before message m₂
• AND m₂ depends on m₁ (causal relation)
• Then:
• The receiver must receive m₁ before m₂

MODELS OF COMMUNICATION NETWORKS

•
MODELS OF COMMUNICATION NETWORKS
•

Global State of a Distributed System

 Global State of a Distributed System

Global State of a Distributed System

Channel state = messages that have been sent but not yet received
 Global State of a Distributed System

• For a global snapshot to be meaningful, the states of all the components of the
distributed system must be recorded at the same instant.
• This will be possible if the local clocks at processes were perfectly synchronized or
there was a global system clock that could be instantaneously read by the
processes. However, both are impossible.

Cuts of a Distributed Computation

 Cuts of a Distributed Computation

Global state defined by the cut

• A cut is a zig-zag line that intersects each process line exactly once.
• Everything to the left → PAST
• Everything to the right → FUTURE
• Each cut represents one global state of the distributed system.
Global state defined by the cut
Global state defined by the cut
•

Global state defined by the cut

• Channel state (very important)
• A channel state captures messages in transit.
• A message is:
• Sent before the cut
• But received after the cut
 Cuts of a distributed computation
• A consistent global state corresponds to a cut in which every message
received in the PAST of the cut was sent in the PAST of that cut. Such a
cut is known as a consistent cut.
• All messages that cross the cut from the PAST to the FUTURE are in
transit in the corresponding consistent global state.
• A cut is inconsistent if a message crosses the cut from the FUTURE to the
PAST.
• For example, the space–time diagram of Figure 2.3 shows two cuts, C1
and C2.
• C1 is an inconsistent cut, whereas C2 is a consistent cut. Note that these
two cuts respectively correspond to the two global states GS1 and GS2.

Cuts of a Distributed Computation Past and Future Cones of an

Event
Past and Future Cones of an Event
Past cones in a distributed computation.
•

Past cones in a distributed computation.

• Max_Past(ej) consists of the latest event at every process that affected
event ej and is referred to as the surface of the past cone of ej

• It must be a message send event. Max_Pastej is a consistent cut .

• For every process:
• Take its latest event that influenced e_j
• Collect all of them
• This gives one event per process
 Cuts of a Distributed Computation
Past and Future Cones of an Event

Future cones in a distributed computation

• Likewise, we can define Futurei (ej) as the set of those events of
Future(ej) that are on process pi and min(Futurei(ej)) as the first event
on process pi that is affected by ej.
• Note that min(Futurei(ej)) is always a message receive event.
Likewise, Min_Past(ej) , defined as, consists of the first
event at every process that is causally affected by event ej and is
referred to as the surface of the future cone of ej .
• It denotes a consistent cut in the computation . Future(ej) represents
all events on the future light cone that are affected by ej.
Models of Process Communications

Models of Process Communications

 Load balancing
• The goal of load balancing is to gain higher throughput, and reduce the user perceived latency.

• Load balancing may be necessary because of a variety of factors such as high network traffic or high request
rate causing the network connection to be a bottleneck, or high computational load

• the objective is to service incoming client requests with the least turnaround time.

• The following are some forms of load balancing:

• • Data migration -The ability to move data (which may be replicated) around in the system, based on the
access pattern of the users.

• • Computation migration- The ability to relocate processes in order to perform a redistribution of the
workload.

• • Distributed scheduling -This achieves a better turnaround time for the users by using idle processing
power in the system more efficiently.