An operating system acts as an intermediary between the user and computer hardware. It manages hardware resources and provides a suitable environment for application programs.
The major objectives are:
1. User Convenience
The operating system provides an easy environment for users to interact with the computer.
Provides user interfaces.
Makes program execution easier.
Provides facilities for input and output.
Provides file-system manipulation.
Provides communication facilities.
Detects errors during system operation.
The OS services include program execution, I/O operations, file-system manipulation, communication and error detection.
2. Efficient Resource Utilization
The operating system acts as a resource allocator.
The major resources managed by an OS are:
CPU time
Main memory
File-storage space
I/O devices
In multi-user and multitasking systems, these resources must be allocated among different users and jobs. The OS uses scheduling mechanisms to manage resources efficiently.
3. Resource Sharing
The OS allows several programs and users to share computer resources.
For example, CPU time, memory, files and I/O devices can be shared among different processes.
4. Protection and Controlled Access
The operating system controls access to system resources so that only authorized users and processes can access them. Protection improves system reliability.
5. Improved System Performance
The OS manages CPU scheduling, memory and I/O operations to improve resource utilization and system performance.
---
The common system components/functions of an operating system include:
1. Process Management
2. Main-Memory Management
3. File Management
4. I/O System Management
5. Secondary-Storage Management
6. Networking
7. Protection System
8. Command-Interpreter System
---
A process is a program in execution. A process requires resources such as CPU time, memory, files and I/O devices.
The operating system performs:
Creation and deletion of user and system processes.
Suspending and resuming processes.
Process synchronization.
Process communication.
Deadlock handling.
Reclaiming resources after process termination.
Example: A word-processing program running while sending output to a printer is handled as a process by the OS.
---
Main memory is directly accessed by the CPU. Programs and data must be loaded into main memory before execution.
The OS performs:
Keeping track of used and free memory.
Identifying which process is using memory.
Deciding which processes should be loaded.
Allocating memory.
Deallocating memory after use.
Several programs may be kept in memory to improve CPU utilization and response speed.
---
A file is a collection of related information stored on secondary storage.
The OS manages:
File creation and deletion.
Directory creation and deletion.
Reading and writing files.
File manipulation.
Mapping files onto secondary storage.
File backup.
Access control for multi-user systems.
Example: Creating, opening, reading, writing and deleting a student record file.
---
The OS hides the internal details of I/O devices from users.
The I/O subsystem contains:
Buffering
Caching
Spooling
General device-driver interface
Device drivers for specific hardware
Device drivers communicate with individual hardware devices.
Example: When a user prints a document, the OS communicates with the printer through its device driver.
---
Main memory is volatile and cannot permanently store all programs and data. Therefore, secondary storage such as disks is used.
The OS performs:
Free-space management.
Storage allocation.
Disk scheduling.
---
A distributed system consists of different computer systems connected through a communication network.
The OS provides access to shared resources and supports:
Resource sharing.
Communication between systems.
Data availability.
Increased reliability.
Network file access.
FTP and NFS are examples mentioned in the material.
---
Protection controls access by users, programs and processes to system and user resources.
It provides:
Controlled resource access.
Authorized user access.
Improved system reliability.
Protection of process address spaces.
---
The command interpreter reads and executes commands given to the operating system.
It handles commands related to:
Process creation and management.
I/O handling.
Secondary-storage management.
Main-memory management.
File-system access.
Protection.
Networking.
In UNIX, the command interpreter is commonly called the shell.
---
The evolution of operating systems occurred through four generations.
Large mechanical and early electronic machines were used.
These systems did not have operating systems.
Instructions were supplied directly to the machine.
If an error occurred, the complete process had to be restarted.
These systems were known as serial processing systems.
Serial Processing
Instructions were executed sequentially.
Instruction A → Instruction B → Instruction C
↓ ↓ ↓
CPU executes instructions sequentially
The instructions entered first were executed first, following a FIFO manner.
---
The second generation introduced Batch Operating Systems.
A batch is a group of similar jobs.
Job Control Language was used to provide instructions.
Instructions were punched onto cards.
Cards were loaded onto tape and submitted to the processor.
Users did not directly interact with the computer.
A major drawback was that the processor remained idle during I/O operations.
Batch Processing Diagram
Batch processing was widely used with mainframe computers. Similar jobs were grouped together and executed as a batch.
---
The third generation introduced multiprogrammed batch systems.
Major features:
Multiprogramming.
Multitasking.
Multiple users could submit tasks.
Jobs were kept in main memory.
CPU scheduling algorithms such as FCFS and SJF were used.
Users could submit tasks through online terminals.
Multiprogramming
---
The fourth generation introduced:
Computer networking.
Networking protocols.
Graphical User Interfaces.
Time-sharing systems.
Round Robin scheduling.
Multi-user systems.
The OS could share CPU time between multiple users, leading to the term Time-Sharing Operating System.
A Batch Operating System groups similar jobs together and executes them as a batch without direct interaction between the user and computer.
Working
1. User prepares the job.
2. Jobs are submitted to the operator.
3. Similar jobs are grouped.
4. The OS executes the batch.
5. Results are produced after processing.
A job consists of a preset sequence of commands, data and programs. Jobs are processed in the order received, and memory is released after successful execution.
Applications / Examples
Mainframe-based job processing.
Groups of similar jobs.
Large sets of jobs that can be processed without user interaction.
---
A Multiprogramming Operating System keeps several jobs in memory simultaneously and switches the CPU to another job when the current job waits for I/O.
Working
Jobs are stored in a job pool on disk.
A subset of jobs is loaded into memory.
The OS selects one job for execution.
If the job waits for I/O, the CPU switches to another job.
This continues until all jobs are completed.
Multiprogramming improves CPU utilization because the CPU can execute another job while one job is waiting.
Main Requirements
Job scheduling.
CPU scheduling.
Memory management.
---
Multitasking allows multiple jobs or programs to execute by rapidly switching the CPU between them.
The study material treats time sharing as a logical extension of multiprogramming and also refers to it as multitasking.
Features
Several programs are maintained in memory.
CPU switches rapidly between programs.
Users can interact with programs while they are running.
Short response time is required.
Example
A computer can keep a browser, text editor and other programs available while the CPU rapidly switches among their processes.
---
A Multiprocessing Operating System supports systems having two or more processors in close communication.
The processors may share:
Computer bus.
Memory.
Clock.
Peripheral devices.
Advantages
1. Increased Throughput
More processors can perform more work in less time. However, the speed-up is less than the number of processors because of overhead and resource contention.
2. Economy of Scale
Processors can share peripherals, mass storage and power supplies, reducing overall cost.
3. Increased Reliability
If one processor fails, the remaining processors can continue the work. This is called graceful degradation.
Types
1. Asymmetric Multiprocessing
2. Symmetric Multiprocessing
In asymmetric multiprocessing, one processor acts as the boss and allocates work to other processors. In symmetric multiprocessing, all processors are peers and perform OS tasks.
Applications / Examples
Multiprocessor systems are used in:
Servers.
Desktop computers.
Laptop computers.
Smartphones and tablets.
---
Time sharing is a logical extension of multiprogramming. The CPU rapidly switches among multiple jobs so that users can interact with their programs.
Features
Supports multiple users.
Uses CPU scheduling and multiprogramming.
Each user has at least one program in memory.
CPU rapidly switches between users.
Provides short response time, typically less than one second.
Requires interactive communication between users and the system.
Example
A multi-user computer system where several users interact with programs simultaneously.
---
A distributed system consists of physically separate and possibly heterogeneous computers connected through a network. The system provides users access to resources maintained by different computers.
Features
Computers are physically separate.
Systems may be heterogeneous.
Resources can be shared.
Communication occurs through networking.
Shared resources increase computation speed.
Provides increased functionality.
Improves data availability.
Improves reliability.
The distributed OS provides a less autonomous environment in which computers communicate closely enough to give the impression that a single operating system controls the network.
Examples / Applications
The material mentions FTP and NFS in distributed-system environments.
---
A Network Operating System provides networking features such as file sharing and communication between processes running on different computers.
Functions
Provides file sharing across the network.
Allows processes on different computers to exchange messages.
Provides access to remote resources.
Uses network protocols for communication.
Client–Server Model
In a client-server system, clients transmit requests and the server attempts to satisfy those requests. Servers can include compute-server systems and file-server systems.
Applications
Network file sharing.
Communication between processes on different computers.
Remote resource access.
File-server systems.
Compute-server systems.
---
A Real-Time Operating System works under well-defined and very strict time constraints. It is used as a control device in dedicated applications.
The system receives input from sensors, analyzes the input and adjusts controls accordingly.
Types of Real-Time Systems
A. Hard Real-Time System
A hard real-time system must complete critical tasks within the required time.
Characteristics:
1. Bounded time delay for receiving input.
2. Bounded time for executing tasks.
3. Bounded time for delivering output.
4. Data may be stored in short-term memory or read-only memory.
5. Advanced OS features such as virtual memory are generally absent.
Input → [Strict Deadline] → Processing → [Strict Deadline] → Output
B. Soft Real-Time System
A soft real-time system does not require strictly bounded delays but gives priority to critical real-time tasks.
Characteristics:
1. Critical real-time tasks receive higher priority.
2. Lack of strict deadline support makes them less suitable for critical applications.
3. Useful in multimedia and virtual reality.
4. Also useful in under-sea exploration and planetary rovers.
5. Supports advanced operating-system features.
Applications
Real-time systems are used in:
Medical imaging systems
Industrial control systems
Home appliance controllers
Multimedia
Virtual reality
Under-sea exploration
Planetary rovers
---
In a monolithic operating system, the whole OS works in kernel space. File management, memory management, device management, and process management are directly controlled inside the kernel, and the kernel can access all resources in the system.
Neat diagram:
Main points:
All major OS services are inside one large kernel.
It is fast because services work in the same address space.
If one service fails, the whole system may fail.
It is an old design used for tasks like batch processing and time-sharing.
Example: Older UNIX-style systems are commonly discussed as monolithic in OS architecture discussions. The file specifically says monolithic systems were first used in the 1970s and control all hardware parts through the kernel.
---
In the layered approach, the OS is divided into a number of layers. The bottom layer is the hardware, and the highest layer is the user interface. Each layer uses only the functions and services of the lower layers. This makes the system modular and easier to debug and verify.
Neat diagram:
Main points:
OS is built in levels, one above another.
Each layer uses only lower-level layers.
Debugging becomes easier because errors can be isolated to one layer.
The difficulty is deciding the correct layer boundaries.
Example: The file shows Windows NT beginning with a layered microkernel organization.
---
A microkernel removes all nonessential components from the kernel and moves them into system-level or user-level programs. The result is a smaller kernel. The microkernel provides minimal process management, memory management, and a communication facility.
Neat diagram:
Main points:
The kernel is kept very small.
Kernel space and user space communicate through IPC.
Client programs do not interact directly with services; they exchange messages through the microkernel.
If one service fails, the rest of the OS remains safe.
It is easier to extend and port, but performance may suffer because of extra overhead.
Examples: Tru64 UNIX, Mac OS X (Darwin), and QNX are given in the file.
---
The file does not give a direct textbook definition of hybrid architecture. From the Windows NT discussion, it can be understood as a mixed design that combines ideas from layered and microkernel systems while moving closer to monolithic design in some versions. This is an inference based on the source, not an explicit definition.
Neat diagram:
Main points:
It combines features of both monolithic and microkernel ideas.
Some parts stay in kernel space, and some parts run in user space.
The source supports this idea through Windows NT, where layers were moved from user space to kernel space, making it more monolithic over time.
It tries to balance performance and modularity. This balance is an inference from the source’s Windows NT discussion.
---
Kernel: Meaning
The kernel is the core part of the operating system that manages the most important OS functions. In the monolithic model, file management, memory management, device management, and process management are directly controlled inside the kernel. In the microkernel model, only minimal process and memory management plus communication remain in the kernel.
---
1. Process Management
The OS handles creation and deletion of user and system processes, suspension and resumption, process synchronization, process communication, and deadlock handling. These are major process-management responsibilities of the OS, and they are core kernel work.
2. Memory Management
The kernel keeps track of which parts of memory are used, decides which processes should be loaded when memory is available, allocates memory, and deallocates memory.
3. Device and I/O Management
The kernel hides device details from the user, uses buffering, caching, and spooling, and works through device drivers for specific hardware devices.
4. File Management
The OS creates, deletes, reads, writes, maps, and backs up files, and it handles directory operations and access control. These file-related operations are part of the kernel-managed system functions.
5. Resource Allocation
The kernel allocates CPU, memory, file storage, and I/O resources to multiple users and jobs, especially in multi-user and multitasking environments.
6. Protection and Security
The kernel controls access to system resources and ensures that only authorized users and processes can access them. It also supports process address-space protection.
7. Communication
The kernel supports communication between processes on the same computer or different systems through shared memory or message passing. In microkernel systems, communication through IPC is especially important.
---
The operating system services listed in the file are:
Program execution
I/O operations
File-system manipulation
Communication
Error detection
Resource allocation
Protection
These services are made available so that programming becomes easier and programs get an execution environment.
Examples:
Program execution: load a program into memory and run it.
I/O operations: handle device-specific operations.
File-system manipulation: create, read, write, and delete files.
Communication: exchange information between processes through shared memory or message passing.
Error detection: detect errors in CPU, memory, I/O devices, or user programs.
Resource allocation: allocate resources to multiple users or jobs.
Protection: control access to resources.
---
1. Central Control Point
The kernel is the main control unit of the OS. It manages hardware resources and coordinates their use by applications and users.
2. Efficient Resource Use
By using schedulers and CPU scheduling algorithms, the kernel improves CPU utilization and manages resources efficiently.
3. Stability and Reliability
Microkernel design shows that keeping only minimal functions in the kernel improves security and reliability, because if one service fails, the rest of the OS remains unaffected. This shows why kernel design is important in OS management.
4. Interface Between User Programs and Hardware
Programs request services from the kernel through system calls. The file defines a system call as a request from a program to the kernel.
5. Improves Modularity and Debugging
In layered and microkernel systems, the kernel design supports modularity, easier debugging, and easier system verification.
---
This shows how the kernel sits between user programs and hardware and controls the core OS services.
Examples:
Text editor
Web browser
Calculator
User applications
The material states that in a monolithic kernel, the entire operating system works in kernel space and services such as memory management, file management and process scheduling operate in the same address space.
| User Mode | Kernel Mode |
|---|---|
| Used by application programs. | Used by the operating system kernel. |
| Has limited access to system resources. | Has privileged access to system resources. |
| Direct hardware access is restricted. | Can access hardware and system resources. |
| Provides a safer environment for user programs. | Performs critical OS operations. |
| A system call is required to request OS services. | Executes the requested OS service. |
| Example: browser, text editor. | Example: process, memory and device management. |
1. User Mode
2. Kernel Mode
A hardware mode bit is used to indicate the current mode of operation.
Important reasons:
1. Protection of OS
Prevents user programs from damaging the operating system.
2. Hardware Protection
Prevents unauthorized direct access to hardware devices.
3. Resource Protection
Controls access to CPU, memory, files and I/O devices.
4. Safe Program Execution
A faulty application cannot directly modify critical kernel data.
5. Controlled Access
User programs request important services through system calls.
A system call is a method by which a computer program requests a service from the OS kernel.
Step 1: Program runs in User Mode
Step 2: Program requests an OS service
For example, the program wants to:
Read a file
Write a file
Access a device
Create a process
It makes a system call.
Step 3: Switch to Kernel Mode
The system call causes the CPU to switch from User Mode → Kernel Mode.
The kernel performs the required operation, such as file or device management.
Step 5: Return to User Mode
After completing the operation, control is returned to the application.
The major services are:
1. Program Execution
2. I/O Operations
3. File-System Manipulation
4. Communication
5. Error Detection
6. Resource Allocation
7. Accounting
8. Protection
The program may terminate either normally or abnormally.
Example
Performance Benefit
It provides a controlled environment for program execution and allows CPU and memory resources to be managed efficiently.
Examples
Keyboard input
Mouse input
Display output
Printer
Disk operations
The OS manages hardware devices efficiently and hides device-specific details from application programs.
Create files
Delete files
Open files
Read files
Write files
These file-system operations are explicitly listed in the material.
Performance Benefit
The OS organizes files and provides controlled access, making data storage and retrieval easier and more efficient.
Processes may communicate:
On the same computer
On different computers connected through a network
The material describes communication as the exchange of information between processes.
A browser process communicates with another process to obtain required information.
Performance Benefit
Communication allows processes to work together and share information.
Errors may occur in:
CPU
Memory
I/O devices
Programs
The OS detects such errors and takes appropriate action.
Early error detection prevents system failures and improves system reliability.
Resources include:
CPU
Main memory
I/O devices
Storage
Proper resource allocation prevents unnecessary resource wastage and improves overall system utilization.
It helps monitor resource utilization and provides useful information for system management.
Protection prevents unauthorized access and reduces the possibility of one program interfering with another program or system resource.
| OS Service | How it Helps | Example |
|---|---|---|
| Program Execution | Provides controlled program execution | Opening an application |
| I/O Operations | Manages hardware I/O efficiently | Printing a document |
| File Management | Organizes and accesses stored data | Reading a file |
| Communication | Allows processes to exchange information | Process-to-process communication |
| Error Detection | Finds and handles system errors | Detecting memory/I/O errors |
| Resource Allocation | Shares CPU, memory and devices efficiently | Multiple programs running together |
| Accounting | Tracks resource usage | Monitoring CPU usage |
| Protection | Controls access to resources | Preventing unauthorized file access |
A system call is a method used by a computer program to request a service from the kernel of the operating system. It provides an interface between a user program and the operating system.
A user program normally cannot directly access protected operating-system resources. Therefore, it uses a system call to request services such as process creation, file handling, device access and communication.
The supplied material illustrates system calls as the interface between user programs and the underlying operating system/hardware.
System calls are required to:
1. Request OS services from application programs.
2. Control processes and their execution.
3. Create, open, read, write and delete files.
4. Access and control I/O devices.
5. Maintain system information such as date and time.
6. Provide communication between processes.
7. Provide controlled access to protected system resources.
The Unit-I material identifies five major categories:
1. Process Control
2. File Management
3. Device Management
4. Information Maintenance
5. Communication
Process control system calls are used to direct and control processes.
The supplied material includes operations such as:
Create process
Load process
Execute process
Abort process
End process
Terminate process
Process-control calls are used when:
A new application is started.
A process needs to execute another program.
A process finishes its execution.
A process has to be terminated.
Example: When a user opens a web browser, the OS creates and executes the required process.
File-management system calls are used to handle files.
The supplied material lists:
Create
Delete
Open
Close
Read
Write
File-management system calls are used in:
Creating documents
Reading files
Saving data
Updating files
Closing files
Deleting unwanted files
Example: A text editor uses file system calls to open a document, read its contents and save modifications.
Device-management system calls are used to communicate with and control I/O devices.
The supplied material gives examples such as:
Read from device
Write to device
Get device attributes
Release device
Used for:
Keyboard input
Printer output
Disk access
Display operations
Other I/O devices
Example: When a document is printed, the application requests the OS to communicate with the printer through device-management mechanisms.
Information-maintenance system calls are used to maintain and obtain information related to the system.
The supplied material includes:
Get system data
Set system data
Get time/date
Set time/date
These calls are useful for:
Obtaining current date and time
Setting system date/time
Obtaining system-related information
Maintaining system information
Example: A clock application requests the current system time through an OS service.
Communication system calls provide communication between processes.
The supplied material lists:
Create communication connection
Delete communication connection
Send messages
Receive messages
Communication system calls are used for:
Inter-process communication
Message exchange
Network communication
Sharing information between processes
Example: Two processes exchange data using send and receive operations.
| Category | Main Operations | Example Application |
|---|---|---|
| Process Control | Create, load, execute, abort, terminate | Starting an application |
| File Management | Create, delete, open, close, read, write | Text editor |
| Device Management | Read, write, get attributes, release | Printer/keyboard |
| Information Maintenance | Get/set system data, time/date | Clock application |
| Communication | Create/delete connection, send, receive | Process communication |
These five categories and their associated operations are directly covered in the supplied Unit-I material.
A monolithic kernel is an OS architecture in which the major operating-system components work inside the kernel space. File management, memory management, device management and process management are directly controlled within the kernel.
Entire OS works in kernel space.
Major services share the same address space.
It is implemented as a static single binary.
Services such as memory management, file management and process scheduling are implemented within the same address space.
1. High performance because services operate in the same address space.
2. Fast communication between OS components.
3. Direct interaction between kernel components.
4. Suitable when execution speed is important.
1. A failure in one service can affect the entire system.
2. Large and complex kernel.
3. Adding or modifying services can require modification of the OS.
4. Less isolation between components.
The supplied material describes monolithic systems as being used for tasks such as batch processing and time-sharing, including older systems used in banking environments.
A microkernel removes non-essential components from the kernel and implements them as system-level or user-level programs, resulting in a smaller kernel.
The supplied diagram shows applications communicating with services such as application IPC, device driver, UNIX server and file server through the microkernel.
Small kernel.
Minimal process and memory management.
Communication facility is maintained in the kernel.
Services can run in user space.
Communication takes place through IPC and message passing.
1. Better reliability — failure of one service need not affect the whole OS.
2. Better security through separation of services.
3. Easy extension — new services can be added in user space.
4. Easy portability to different hardware.
5. Smaller kernel is easier to maintain.
1. Communication between components introduces overhead.
2. Message passing can reduce performance.
3. More complex communication mechanisms are required.
The supplied material specifically notes that microkernel performance can suffer because of increased system-function overhead.
Examples given in the material include:
Tru64 UNIX
Mac OS X (Darwin)
QNX / Neutrino microkernel
In the Layered Approach, the operating system is divided into a number of layers, where each layer is built on top of lower-level layers.
The bottom layer (Layer 0) is hardware and the highest layer (Layer N) is the user interface.
OS is divided into levels.
Each layer uses functions and services of only lower-level layers.
Hardware forms the lowest layer.
User interface forms the highest layer.
1. Modularity
2. Easier debugging.
3. Easier system verification.
4. Errors can be isolated to a particular layer.
5. Easier maintenance because individual layers can be considered separately.
1. Difficult to divide an OS into appropriate layers.
2. Difficult to decide the exact position of each component.
3. A service may need functions from multiple layers, making design difficult.
The layered approach is suitable for systems where:
Modularity is important.
Debugging and verification are important.
Clear separation between system functions is required.
Hybrid architecture combines ideas from different OS architectures, mainly the monolithic and microkernel approaches. It attempts to obtain the performance of a monolithic design while retaining some modularity and separation associated with microkernels.
Combines features of multiple architectures.
Some services operate in kernel space for performance.
Other components may be separated or modularized.
Attempts to balance performance, reliability and modularity.
1. Better performance than a pure microkernel in many designs.
2. More modular than a completely monolithic design.
3. Allows selected services to run closer to the kernel.
4. Provides a balance between performance and system organization.
1. More complex architecture.
2. Clear separation between kernel and services can be difficult.
3. A larger privileged component can reduce some of the reliability benefits of a pure microkernel.
4. Design and maintenance can be complicated.
Hybrid approaches are associated with modern general-purpose operating systems. Common textbook examples include Windows NT-family systems and Apple's XNU-based systems, although the exact internal organization differs between versions.
| Feature | Monolithic Kernel | Microkernel | Layered Architecture | Hybrid Architecture |
|---|---|---|---|---|
| Basic structure | Most OS services inside kernel | Minimal kernel + user-space services | OS divided into layers | Combination of architectural approaches |
| Kernel size | Large | Small | Depends on design | Medium/large |
| Services | Mainly kernel space | Many services in user space | Organized into layers | Selected services may be in kernel |
| Communication | Direct kernel-component communication | IPC/message passing | Through adjacent layers | Combination of direct and modular communication |
| Performance | High | May suffer IPC overhead | Depends on layers | Generally designed to balance performance |
| Modularity | Low | High | High | High/moderate |
| Reliability | Lower isolation | High isolation | Good separation | Better than pure monolithic in many designs |
| Security | More privileged components | Stronger separation | Layer-based control | Depends on implementation |
| Debugging | More difficult | Easier for isolated services | Easier | Moderate |
| Failure handling | Failure may affect whole system | Failed service can be isolated | Depends on affected layer | Depends on component placement |
| Main advantage | Speed | Reliability and modularity | Simplicity of organization | Balance of performance and modularity |
| Main disadvantage | Large, tightly coupled kernel | IPC overhead | Difficult layer design | Architectural complexity |
Monolithic: Entire OS services are mainly inside the kernel; fast but less isolated.
Microkernel: Keeps the kernel small and moves many services to user space; modular, reliable and portable, but IPC can introduce overhead.
Layered: Divides the OS into levels; each layer uses lower-level services; modular and easier to debug, but designing appropriate layers is difficult.
Hybrid: Combines architectural ideas to obtain a practical balance between performance, modularity and reliability; this portion is not separately covered in the supplied Unit-I material.
An Operating System (OS) manages computer hardware and coordinates the use of resources such as CPU, memory, I/O devices and storage among application programs and users.
Different types of operating systems are designed for different requirements. The major types covered in the Unit-I material include Serial Processing, Batch Processing, Multiprogramming, Time-Sharing, Multiprocessor/Parallel, Distributed, and Real-Time Operating Systems.
In serial processing, instructions are executed sequentially, generally following a FIFO (First-In, First-Out) approach.
Performance: Low because only one instruction/job is processed at a time.
Resource utilization: Low; CPU and other resources may remain idle.
Response time: Poor for multiple jobs because jobs wait for previous jobs.
Reliability: Simple structure makes it relatively easy to understand and control.
Suitable applications: Very simple or early computer systems where jobs are executed sequentially.
In batch processing, similar jobs are collected into a batch and processed sequentially without requiring continuous user interaction.
Performance: Better than simple serial processing for groups of similar jobs.
Resource utilization: Reasonably efficient for large batches, but CPU can remain unused during I/O or waiting periods.
Response time: Poor, because users do not receive immediate results.
Reliability: Suitable for repetitive, well-defined jobs.
Suitable applications: Payroll processing, billing, report generation and other large offline jobs.
A multiprogramming system keeps multiple jobs in memory. When one job waits for I/O, the CPU switches to another job. This substantially increases CPU utilization.
Performance: High CPU utilization and improved throughput.
Resource utilization: Very good, because the CPU can work on another job while one job waits.
Response time: Better than batch processing, but not necessarily optimized for immediate user interaction.
Reliability: Requires proper memory and CPU management.
Suitable applications: Multi-job computing environments, servers and systems running several programs simultaneously.
The OS requires job scheduling, CPU scheduling and memory management to support multiprogramming.
Time sharing is a logical extension of multiprogramming. The CPU rapidly switches between jobs so that users can interact with their programs while they are executing.
Performance: Good for interactive multi-user environments.
Resource utilization: High because CPU time is shared among multiple users.
Response time: Very good; the supplied material states that response time should typically be less than one second.
Reliability: Requires effective scheduling and memory management.
Suitable applications: University computer labs, interactive servers, desktop systems and multi-user systems.
This is particularly suitable where many users need simultaneous interactive access.
A multiprocessor system contains two or more processors that communicate closely and may share the bus, memory, clock and peripheral devices.
Performance: Very high, because multiple processors can execute tasks concurrently.
Resource utilization: High because processors and shared resources can be used simultaneously.
Response time: Generally good, particularly under heavy workloads.
Reliability: High; if properly distributed, failure of one processor need not stop the entire system.
Suitable applications: Servers, scientific computing, large databases, high-performance computing and modern multi-core computers.
1. Increased throughput
2. Economy of scale
3. Increased reliability
The supplied material specifically explains that multiple processors can increase throughput and that a processor failure may only reduce performance rather than completely halt the system.
A distributed system consists of physically separate, possibly heterogeneous computers connected through a network to provide users access to shared resources.
Performance: High because computation can be distributed among multiple machines.
Resource utilization: Very high because resources can be shared across systems.
Response time: Can be good, depending on network performance and workload.
Reliability: High, because shared resources and multiple systems can provide improved availability.
Suitable applications: University campuses, cloud environments, research networks, distributed databases and large organizations.
The material states that sharing resources can provide increased computation speed, functionality, data availability and reliability.
A real-time operating system is designed for systems having well-defined and strict time constraints. It is used for dedicated applications that need timely processing.
There are two types:
Critical tasks must be completed within their specified deadlines.
Characteristics include bounded time delay for receiving input, executing tasks and delivering output.
Critical control systems
Certain medical systems
Industrial control
Safety-critical systems
Critical tasks receive priority, but strict bounded delays are not necessarily required.
Multimedia
Virtual reality
Under-sea exploration
Planetary rovers
Performance: Excellent for deadline-sensitive tasks.
Resource utilization: Optimized toward predictable execution.
Response time: Extremely important and predictable.
Reliability: High when correctly designed for the target application.
Suitable applications: Control systems and other time-sensitive applications.
| OS Type | Performance | Resource Utilization | Response Time | Reliability | Suitable Application |
|---|---|---|---|---|---|
| Serial | Low | Low | Poor | Good for simple tasks | Simple sequential jobs |
| Batch | Moderate | Moderate | Poor | Good for repetitive jobs | Payroll, billing, reports |
| Multiprogramming | High | High | Moderate | Good | Multi-job systems |
| Time-Sharing | High | High | Very good | Good | Labs, interactive multi-user systems |
| Multiprocessor | Very high | Very high | Good | High | Servers, HPC, databases |
| Distributed | High | Very high | Good, network-dependent | High | Campus/cloud/network systems |
| Real-Time | High/predictable | Application-dependent | Excellent/predictable | Very high for intended tasks | Industrial/control systems |
There is no single best OS type for every situation. Batch systems are suitable for large repetitive jobs, multiprogramming improves CPU utilization, time-sharing provides fast interactive access, multiprocessor systems improve throughput and reliability, distributed systems provide resource sharing and availability, while real-time systems are designed around strict timing requirements.
Assume we are designing a University Campus Operating System (UCOS) for a modern university containing:
Thousands of students
Faculty and administrative staff
Computer laboratories
Library systems
Department servers
Student portals
Learning Management System
Examination systems
Wi-Fi and campus networking
Research/HPC systems
Printers and other shared devices
Central databases
Cloud-based applications
The OS should therefore support multi-user operation, networking, resource sharing, security, high availability and interactive response.
The best solution would not be a single isolated OS running on one computer. Instead, the campus infrastructure should use a networked/distributed environment with time-sharing capabilities and multiprocessor servers.
A university has many users who need to interact with systems simultaneously.
For example:
Time-sharing allows many users to share computing resources while maintaining interactive response. The supplied material specifically states that time-sharing allows many users to share the computer simultaneously and requires short response time.
A university may have separate:
Central server
Library server
Examination server
Department servers
Research servers
File servers
A distributed approach allows users to access resources across connected systems. Shared resources can increase speed, functionality, data availability and reliability.
University servers may handle thousands of simultaneous requests.
Multiple processors can improve throughput, and properly distributed workloads can improve reliability.
For a modern university, I would select a hybrid architecture combining the performance benefits of a monolithic kernel with modular separation of services.
A university requires both:
High performance for servers and laboratories.
Modularity for maintenance and expansion.
Reliability because academic systems should remain available.
Security because student and faculty data must be protected.
A purely monolithic design can provide high performance but has weaker isolation when a kernel service fails. The supplied material notes that monolithic services share the same address space and that failure of a service can lead to failure of the entire system.
A microkernel provides stronger separation and reliability, but IPC can introduce system-function overhead.
Therefore, a hybrid design provides a practical balance.
The kernel should provide the core functions that require high performance and strong control over hardware.
1. Process management
2. CPU scheduling
3. Memory management
4. Device management
5. File-system support
6. Networking
7. Inter-process communication
8. Security and protection
The OS is fundamentally responsible for managing hardware resources such as CPU, memory and I/O devices.
The campus OS may have thousands of simultaneous processes.
The OS should provide:
Process creation
Process termination
CPU scheduling
Multitasking
Process synchronization
Inter-process communication
The supplied material identifies CPU scheduling as the mechanism for selecting which ready job should execute.
Memory management is essential because many users and applications may operate simultaneously.
Memory allocation
Memory deallocation
Process isolation
Efficient memory utilization
Virtual memory support
Protection of one process from another
Multiprogramming specifically requires efficient memory management to keep several jobs in memory simultaneously.
The university will have enormous amounts of:
Student documents
Assignments
Examination files
Research data
Faculty documents
Library resources
Administrative records
Therefore, the OS should provide:
Create files
Delete files
Read/write files
Directory management
File permissions
Storage allocation
Backup support
The supplied material identifies file-system manipulation as an important OS service, including the ability to read, write, create and delete files.
The campus uses many I/O devices:
Printers
Keyboards
Displays
Storage devices
Scanners
Network interfaces
Laboratory equipment
The OS should provide device drivers and I/O services.
The supplied material specifically identifies I/O operations as an OS service that provides mechanisms for performing I/O and supporting device-specific functions.
Networking is one of the most important services for a university.
The OS should support:
TCP/IP networking
Wi-Fi connectivity
File sharing
Network authentication
Remote access
Inter-process communication
Server communication
Distributed systems depend on networking and allow shared resources to be accessed across connected systems.
This is one of the highest-priority requirements for a university.
The OS should protect:
Student records
Marks
Attendance
Examination data
Faculty records
Research data
Financial information
Login credentials
The supplied material defines protection as controlling access by programs, processes and users to system and user resources.
The OS should continuously detect errors in:
CPU
Memory
I/O devices
User programs
Network operations
Error detection is identified as an OS service for maintaining correct computation.
For critical university services, backup servers and redundant resources should also be used.
University systems require large storage capacity for student and research data.
The OS should provide:
Free-space management
Storage allocation
Disk scheduling
Backup and recovery
These are identified as OS responsibilities in secondary-storage management.
Thousands of users may request resources simultaneously.
The OS should decide:
Who gets CPU?
Who gets memory?
Who gets storage?
Who gets printer access?
Who gets network resources?
Resource allocation is an additional OS function used to allocate resources among multiple users or jobs running simultaneously.
The university may need to monitor:
CPU usage
Storage usage
Network usage
Laboratory usage
User activity
The supplied material identifies accounting as keeping track of which users consume computer resources and how much they use.
Processes on the same server or different campus computers need to exchange information.
The OS should support:
Shared memory
Message passing
Inter-process communication
Network communication
The supplied material identifies communication as an OS service for exchanging information between processes on the same computer or on different networked systems.
| System Service | Purpose in University |
|---|---|
| Program Execution | Run LMS, ERP, library and student applications |
| Process Management | Manage thousands of simultaneous applications |
| Memory Management | Efficiently share RAM between users/processes |
| File-System Management | Store assignments, records and research data |
| I/O Management | Control printers, storage and laboratory devices |
| Networking | Connect campus systems and Internet |
| Communication | Allow processes and servers to exchange data |
| Error Detection | Detect hardware/software failures |
| Resource Allocation | Share CPU, memory, storage and devices |
| Accounting | Track resource usage |
| Protection/Security | Protect student, faculty and administrative data |
| Secondary Storage Management | Manage large-scale permanent storage |
The core services of program execution, I/O, file manipulation, communication and error detection are explicitly identified in the supplied material.
For a modern university campus, I would select a time-sharing and distributed operating-system environment, supported by multiprocessor servers.
The architecture would preferably be hybrid, with a hybrid kernel providing process management, memory management, scheduling, I/O, networking, communication and protection.
This choice is justified because a university requires:
High performance → multiprocessor servers
High resource utilization → multiprogramming/time sharing
Fast response → time-sharing
Resource sharing → distributed/networked systems
High availability and reliability → multiple servers/processors
Strong security → protection and controlled access
Scalability → modular/hybrid architecture
Large-scale storage → secondary-storage management
Continuous communication → networking and IPC
Thus, the proposed system can efficiently support students, faculty, administration, laboratories, library services, examinations, research and campus-wide digital applications while maintaining performance, resource utilization, response time and reliability.
0 Comments