ADVANCE OPERATING SYSTEM

UNIT-I

SYLLABUS:
UNIT-1: Architectures of Distributed Systems, System Architecture types, issues in distributed
operating systems, communication networks, communication primitives. Theoretical Foundations,
inherent limitations of a distributed system, lamp ports logical clocks, vector clocks, casual ordering
of messages, global state, cuts of a distributed computation, termination detection. Distributed
Mutual Exclusion, introduction, the classification of mutual exclusion and associated algorithms, a
comparative performance analysis.

NOTES:
1.1 Architectures of Distributed Systems:
Distributed systems architectures come in various forms to
address different requirements and challenges. Here are some common
architectures in distributed systems:

1. Client-Server Architecture:
 This is one of the simplest distributed system architectures.
 Clients request services or resources from servers, which fulfill
these requests.
 It is widely used in web applications where browsers (clients)
communicate with web servers.
2. Peer-to-Peer (P2P) Architecture:
 In a P2P architecture, all nodes in the network can act as both
clients and servers.
 Nodes can share resources directly without the need for a
centralized server.
 Often used in file-sharing systems and decentralized
networks.
3. Microservices Architecture:
 Applications are built as a collection of small, independent
services that communicate through APIs.
 Each service focuses on a specific business capability and can
be developed, deployed, and scaled independently.
 Promotes flexibility, scalability, and ease of maintenance.
4. Service-Oriented Architecture (SOA):
 Components provide services to other components through a
communication protocol.
  Services are designed to be loosely coupled and reusable
across different applications.
 Aims to create a modular and flexible architecture.
5. Event-Driven Architecture:
 Components communicate by generating and reacting to
events.
 Allows for asynchronous communication and decoupling of
components.
 Suitable for systems where real-time responses to events are
crucial.
6. Message-Oriented Middleware (MOM):
 Middleware facilitates communication between distributed
components through message passing.
 Queues and topics are used to handle communication
between different parts of the system.
 Provides reliable and asynchronous communication.
7. Three-Tier Architecture:
 Divides the system into three layers: presentation, application
(business logic), and data.
 Common in web applications, where the user interface,
processing, and data storage are separate.
8. Cloud Computing Architectures:
 Utilizes the cloud for delivering computing services over the
internet.
 Includes Infrastructure as a Service (IaaS), Platform as a
Service (PaaS), and Software as a Service (SaaS)
architectures.
 Offers scalability, flexibility, and cost-effectiveness.
9. Edge Computing Architecture:
 Processing is performed closer to the data source or "edge" of
the network.
 Reduces latency and is beneficial for applications requiring
real-time processing, such as IoT devices.
10. Hybrid Architectures:
 Combines elements of different architectures to leverage their
strengths.
 For example, a system might use microservices for scalability
and a centralized database for consistency.

Each distributed systems architecture has its own advantages and trade-
offs, and the choice depends on the specific requirements of the
application, scalability needs, fault tolerance goals, and other factors. The
complexity of modern applications often leads to the adoption of hybrid
approaches that combine multiple architectural styles.
1.2 System Architecture types:

In advanced operating systems, system architecture types often involve

sophisticated structures, designs, and mechanisms to handle the
complexities of modern computing environments. Here are some key
types of system architectures in advanced operating systems:

1. Microkernel Architecture:
 The microkernel architecture minimizes the kernel's
functionality, delegating most tasks to user-level processes or
modules.
 Core services, such as inter-process communication (IPC) and
memory management, are implemented in the microkernel.
 Provides flexibility, modularity, and ease of maintenance.
2. Exokernel Architecture:
 In exokernel architectures, the kernel provides minimal
abstractions, allowing applications to directly manage
hardware resources.
 Offers fine-grained control over resources, enabling
applications to make more efficient use of hardware.
3. Nanokernel Architecture:
 Similar to microkernels but with an even more minimalistic
design, nanokernels focus on reducing overhead.
 Often used in embedded systems and environments with
resource constraints.
4. Virtual Machine Architecture:
 Virtual machine architectures allow the execution of multiple
operating system instances on a single physical machine.
 Each virtual machine runs its own operating system, providing
isolation and flexibility.
 Commonly used in cloud computing environments for
resource consolidation.
5. Hybrid Kernel Architecture:
 Hybrid kernels combine elements of both monolithic and
microkernel architectures.
 They aim to provide the performance benefits of monolithic
kernels while maintaining the modularity of microkernels.
 Examples include the Windows NT kernel.
6. Multikernel Architecture:
 In multikernel architectures, multiple kernels run on a single
machine, each managing a subset of the hardware resources.
 Focuses on scalability and fault tolerance by allowing multiple
kernels to operate independently.
7. Distributed Operating System Architecture:
 Distributed operating systems extend their functionality
across multiple machines connected by a network.
 Components may be geographically distributed, and the
system must handle communication, synchronization, and
resource sharing across nodes.
8. Clustered Architecture:
 Clustering involves the grouping of multiple computers to
work together as a single system.
 The cluster operates as a single entity, sharing resources and
providing high availability and load balancing.
9. Decentralized Architecture:
 In decentralized architectures, there is no central point of
control.
 Nodes in the system collaborate and make decisions
collectively, promoting fault tolerance and scalability.
10. Reflective Architecture:
 Reflective architectures allow the system to observe, modify,
and reason about its own structure and behavior at runtime.
 Enhances adaptability and self-optimization of the operating
system.

These advanced operating system architectures are designed to address

specific challenges such as scalability, fault tolerance, security, and
adaptability. The choice of architecture often depends on the intended use
case, system requirements, and the trade-offs between factors such as
performance, modularity, and complexity.

1.3 issues in distributed operating systems:

Distributed operating systems introduce a set of challenges and

issues that need to be addressed to ensure the proper functioning
of the system. Here are some common issues in distributed
operating systems:

1. Communication Delays:
 Network latency and communication delays can affect
the performance of distributed systems.
Synchronization and coordination between nodes may
be impacted.
2. Concurrency and Mutual Exclusion:
 Coordinating concurrent processes across multiple
nodes while ensuring mutual exclusion can be
challenging. Distributed systems need mechanisms to
manage shared resources.
3. Fault Tolerance:
 Distributed systems are susceptible to hardware
failures, network issues, and other faults. Designing for
fault tolerance and implementing recovery
mechanisms is crucial.
4. Consistency and Replication:
  Maintaining consistency among replicated data across
different nodes is a complex task. Ensuring that
updates are synchronized and replicas are consistent
poses challenges.
5. Data Integrity and Security:
 Ensuring the integrity and security of data in a
distributed environment is critical. Protecting data
during transmission and storage is an ongoing concern.
6. Scalability:
 Designing distributed systems that can scale
horizontally to handle increased workloads efficiently is
a significant challenge. Scalability must be considered
from the outset.
7. Heterogeneity:
 Distributed systems often involve diverse hardware,
software, and network components. Managing
heterogeneity introduces complexity in terms of
compatibility and interoperability.
8. Load Balancing:
 Balancing the load across nodes to prevent resource
bottlenecks and ensure optimal performance is a
constant concern in distributed systems.
9. Consensus and Coordination:
 Achieving consensus among nodes in a distributed
system, especially in the presence of failures or
network partitions, is a non-trivial problem.
10. Transaction Management:
 Coordinating distributed transactions to ensure
atomicity, consistency, isolation, and durability (ACID
properties) across multiple nodes is challenging.
11. Distributed File Systems:
 Managing distributed file systems involves addressing
issues related to data storage, access, and
synchronization across different nodes.
12. System Monitoring and Diagnosis:
 Monitoring the health and performance of distributed
systems, as well as diagnosing issues when they occur,
can be complex due to the distributed nature of the
environment.
13. Resource Management:
 Efficiently managing resources such as CPU, memory,
and network bandwidth across multiple nodes is crucial
for optimal system performance.
 14. Dynamic Configuration and Adaptability:
 Handling changes in the system, such as node
additions or removals, and adapting to dynamic
configurations require sophisticated mechanisms for
reconfiguration.
15. Clock Synchronization:
 Achieving synchronized clocks across distributed nodes
is essential for proper coordination and timestamp-
based operations.

Addressing these issues involves the use of various distributed

algorithms, protocols, and design principles. Distributed systems
researchers and engineers continually work to develop solutions
that enhance the reliability, performance, and scalability of
distributed operating systems.
1.4 communication networks:
In advanced operating systems, communication networks
play a crucial role in enabling communication and coordination
among distributed components. These networks facilitate the
exchange of information between nodes, which may be
geographically dispersed. Here are key aspects related to
communication networks in advanced operating systems:

1. Message Passing:
 Message passing is a fundamental communication
paradigm in distributed systems. Processes
communicate by sending and receiving messages.
 Advanced operating systems often use efficient
message passing mechanisms to enable inter-process
communication (IPC) across nodes.
2. Remote Procedure Call (RPC):
 RPC allows a program to execute procedures or
functions on a remote machine as if they were local.
 Advanced operating systems use RPC to facilitate
communication between processes or services running
on different nodes.
3. Middleware:
 Middleware provides a layer of abstraction over the
network, simplifying communication between
distributed components.
  It often includes services like object request brokers
(ORBs) for managing distributed objects and
components.
4. Socket Programming:
 Sockets enable communication between processes on
different nodes over a network.
 Advanced operating systems leverage socket
programming for building networked applications.
5. Peer-to-Peer Communication:
 In decentralized systems, peer-to-peer communication
is common. Nodes communicate directly with each
other without relying on a centralized server.
 This architecture is often used in file-sharing
applications and decentralized networks.
6. Group Communication:
 Group communication involves sending messages to a
group of processes simultaneously.
 This is crucial for collaborative applications, distributed
databases, and other scenarios where a group of nodes
needs to coordinate.
7. Publish-Subscribe Systems:
 In publish-subscribe systems, publishers produce
messages, and subscribers express interest in
receiving specific types of messages.
 This model is used for event-driven communication in
distributed systems.
8. Quality of Service (QoS):
 QoS mechanisms are essential for managing the
performance characteristics of communication
networks.
 Advanced operating systems may implement QoS to
prioritize certain types of communication or ensure
minimum bandwidth guarantees.
9. Security Protocols:
 Advanced operating systems incorporate security
protocols to protect communication against
unauthorized access, eavesdropping, and tampering.
 Secure Socket Layer (SSL) and Transport Layer Security
(TLS) are common security protocols.
10. Multicast and Broadcast:
 Multicast and broadcast communication models are
used to send messages to multiple nodes
simultaneously.
  These models are useful for scenarios where
information needs to be disseminated to a group of
recipients.
11. Network Topologies:
 The choice of network topology (e.g., bus, ring, star,
mesh) can impact communication patterns and
reliability in distributed systems.
12. Protocol Stacks:
 Advanced operating systems typically implement
communication protocols using protocol stacks (e.g.,
TCP/IP).
 The protocol stack defines the rules for data
transmission and reception.
13. Network Virtualization:
 Network virtualization allows the creation of multiple
virtual networks on a shared physical network
infrastructure.
 This enables resource isolation and flexibility in
configuring network settings for different applications.

Effective communication networks are critical for the success of

distributed systems. The design and implementation of
communication mechanisms in advanced operating systems aim
to provide reliability, efficiency, and security in supporting diverse
communication patterns and requirements.
1.5 communication primitives:
Communication primitives in advanced operating systems
are fundamental building blocks or operations that facilitate
communication and coordination between processes in a
distributed environment. These primitives provide a high-level
abstraction for inter-process communication (IPC) and help
manage the complexities of distributed systems. Here are some
common communication primitives:

1. Message Passing:
 Send and Receive: Processes can send messages to
other processes and receive messages from them. The
send and receive operations are fundamental in
message-passing systems.
2. Remote Procedure Call (RPC):
 Remote Invocation: Allows a process to invoke a
procedure or function on a remote node as if it were a
 local procedure call. The remote invocation abstracts
the details of the underlying communication.
3. Synchronization Primitives:
 Barrier: A barrier is a synchronization primitive that
forces processes to wait until all processes reach a
certain point before any of them can proceed.
 Semaphore: Semaphores are used for process
synchronization by controlling access to shared
resources using counting mechanisms.
4. Notification Mechanisms:
 Event Notification: Processes can be notified when a
certain event occurs, such as the availability of data,
the completion of a task, or the occurrence of an error.
5. Publish-Subscribe:
 Publish: A process publishes messages or events to a
channel or topic.
 Subscribe: Other processes subscribe to specific
channels or topics and receive messages published to
those channels.
6. Request-Reply:
 Request: One process sends a request message to
another process.
 Reply: The recipient process responds to the request
with a reply message.
7. Futures and Promises:
 Future: Represents the result of an asynchronous
operation that may not have completed yet.
 Promise: A commitment to produce a value at some
point in the future.
8. Transactional Primitives:
 Begin Transaction, Commit, Rollback: These
primitives are used in distributed transactions to
ensure atomicity, consistency, isolation, and durability
(ACID properties).
9. Memory Sharing:
 Read and Write Operations: Processes can perform
read and write operations on shared memory regions
to exchange data efficiently.
10. Multicast and Broadcast:
 Multicast: Sending a message to a specific group of
processes.
 Broadcast: Sending a message to all processes in the
system.
 11. Mutex (Mutual Exclusion):
 Lock and Unlock: Processes can acquire and release
locks to ensure mutual exclusion and prevent
simultaneous access to shared resources.
12. Barrier Synchronization:
 Barrier Creation and Synchronization: Processes
can synchronize at barriers to coordinate their progress
in a parallel or distributed environment.
13. Atomic Operations:
 Atomic Read-Modify-Write Operations: Ensures
that certain operations are executed atomically without
interference from other processes.
14. Distributed File Operations:
 Open, Read, Write, Close: Processes can perform
file operations in a distributed file system.

These communication primitives provide a high-level interface for

developers to design and implement distributed systems without
dealing with the intricacies of low-level network communication.
They help abstract the complexities of network protocols and
hardware details, providing a more manageable and efficient way
to coordinate processes in a distributed operating system.