OS Design Structure Abstraction System Call
OS Design Structure Abstraction System Call
Dr. N.Nalini
SCOPE
VIT
Operating System Design Issues
• The important issues related to Operating system
are
– transparency, flexibility, reliability, performance,
scalability, naming, replication, synchronization,
security.
Operating System Design Issues
Transparency
• Multiple Computers are used but the user gets a view of only single system being used. Makes the
network invisible to user/applications.
Flexibility
• Flexible operating systems are taken to be those whose designs have been motivated to some degree
by the desire to allow the system to be tailored, either statically or dynamically, to the requirements of
specific applications or application domains.
Reliability
• In general, reliability is the ability of a person or system to perform and maintain its functions in routine
circumstances, as well as hostile or unexpected circumstances.
• Reliability is generally considered important by end users. Not all companies making operating systems
have a similar standard. Even among operating systems where reliability is a priority, there is a range of
quality.
• Also, an operating system may be extremely reliable at one kind of task and extremely unreliable at
another. Current operating systems have two characteristics that make them unreliable and insecure.
• They are huge and have very poor fault isolation.
Operating System Design Issues
Performance
• The performance of computer hardware typically increases monotonically with time.
Even if the same could be said of software, the rate at which software performance
improves is usually very slow compared to that of hardware.
• In fact, many might opine that there is plenty of software whose performance has
deteriorated consistently with time.
• Moreover, it is rather difficult to establish an objective performance metric for
software as complex as an operating system: a "faster OS" is a very subjective, context
dependent phrase.
Operating System Design Issues
Scalability
• Scalability is a desirable property of a system, a network, or a process, which indicates
its ability to either handle growing amounts of work in a graceful manner, or to be
readily enlarged.
• A system whose performance improves after adding hardware, proportionally to the
capacity added, is said to be a scalable system.
Naming
• The resources in a distributed system are spread across different computers and a
naming scheme has to be devised so that users can discover and refer to the resources
that they need.
• An example of such a naming scheme is the URL (Uniform Resource Locator) that is
used to identify WWW pages.
– If a meaningful and universally understood identification scheme is not used then many of these
resources will be inaccessible to system users.
Operating System Design Issues
Replication
• Replication is one of the oldest and most important topics in the overall
area of distributed systems. Whether one replicates data or computation,
the objective is to have some group of processes that handle incoming
events.
• If we replicate data, these processes are passive and operate only to
maintain the stored data, reply to read requests, and apply updates.
When we replicate computation, the usual goal is to provide fault-
tolerance.
Operating System Design Issues
Synchronization
• Processes requires coordination to achieve synchronization. Process must reach a
common synchronization point before they can continue.
• A process must wait for a condition that will be set asynchronously by other
interacting processes to maintain some ordering of execution. Concurrent processes
must have mutual exclusion when accessing a critical shared resource.
Security
• Authentication: Clients, Servers and messages must be authenticated
• Authorization: Access control has to be performed across a physical network with
heterogeneous components under different administrative units using different
security models.
OS Abstraction
• The operating system provides a layer of abstraction between the user and
the bare machine. Users and applications do not see the hardware directly, but view
it through the operating system.
• This abstraction can be used to hide certain hardware details from
users and applications. Thus, changes in the hardware are not seen by the user (even
though the OS must accommodate them).
• This is particularly advantageous for venders that want offer a consistent OS interface
across an entire line of hardware platforms.
• Another way that abstraction can be used is to make related devices appear the same
from the user point of view.
• For example, hard disks, floppy disks, CD-ROMs, and even tape are all very different
media, but in many operating systems they appear the same to the user.
• Abstraction
– Hide the implementation details of a
component
Abstraction
– Freedom to modify the implementation without
affecting other underlying modules Component -1
– Ex: int add(int a, int b) { Interface
return a + b; // Implementation details
} Abstraction
• Interface Component -2
– To hide the details of lower level components
– To enable the communication / data passing
between the components without knowing Take away:
details of their implementation
– Ex: printf(“%d, %d”, add(5,10), add(10,10)) If you introduce an interface,
you want to hide the
implementation details
below it
Operating System Structure
• General-purpose OS is very large program
• Various ways to structure ones
– Simple structure – MS-DOS
– Monolithic Structure– Traditional/old UNIX
– Modular - Linux
– Layered – an abstraction -Unix
– Microkernel – Mach
SIMPLE STRUCTURE
• It is the most straightforward operating system
structure, but it lacks definition and is only
appropriate for usage with tiny and restricted
systems.
• The interfaces and levels of functionality are not well
separated. MS-DOS is an example of such operating
system.
• In MS-DOS application programs are able to access
the basic I/O routines.
• These types of operating system cause the entire
system to crash if one of the user programs fails.
Simple structure
Advantages of Simple structure:
• It delivers better application performance because of the few interfaces between the
application program and the hardware.
• Easy for kernel developers to develop such an operating system.
• Protection
– Control access to resources
– Get and set permissions
– Allow and deny user access
Examples of Windows and Unix System Calls