Operating Systems 1st Assignment

Full text

Shahid Beheshti University
Operating Systems
Mohammad Karbalaee
1st Assignment
October 28, 2023
Contents
1 1st Q&A 1
1.1 Question................................................. 1
1.2 Answer ................................................. 1
2 2nd Q&A 2
2.1 Question................................................. 2
2.2 Answer ................................................. 2
3 3rd Q&A 2
3.1 Question................................................. 2
3.2 Answer ................................................. 2
4 4th Q&A 3
4.1 Question................................................. 3
4.2 Answer ................................................. 3
5 5th Q&A 3
5.1 Question................................................. 3
5.2 Answer ................................................. 4
6 6th Q&A 5
6.1 Question................................................. 5
6.2 Answer ................................................. 5
7 7th Q&A 5
7.1 Question................................................. 5
7.2 Answer ................................................. 5

8 8th Q&A 5
8.1 Question................................................. 5
8.2 Answer ................................................. 5
9 9th Q&A 6
9.1 Question................................................. 6
9.2 Answer ................................................. 6
10 10th Q&A 7
10.1Question................................................. 7
10.2Answer ................................................. 7
11 11th Q&A 8
11.1Question................................................. 8
11.2Answer ................................................. 8
12 12th Q&A 9
12.1Question................................................. 9
12.2Answer ................................................. 9
2

1 1st Q&A
1.1 Question
Which of the following instructions should be privileged?
1. Set value of timer.
2. Read the clock.
3. Clear memory.
4. Issue a trap instruction.
5. Turn off interrupts.
6. Modify entries in device-status table.
7. Switch from user to kernel mode.
8. Access I/O device.
1.2 Answer
In the context of operating systems and computer architecture, the privilege level of various instructions is
crucial for ensuring system stability and security. When considering which instructions should be privileged,
it’s essential to differentiate between instructions that require elevated permissions and those that can be
executed in a less privileged user mode.
1. Set value of timer: This operation should be privileged because it controls the system’s timing and is
critical for scheduling tasks and maintaining system stability.
2. Clear memory: Clearing memory should also be privileged since it can impact the integrity of data
and the execution of processes. Unauthorized memory clearing could lead to data corruption.
3. Turn off interrupts: Disabling interrupts is a privileged operation as it affects the core functionality of
the system. Inappropriate interrupt handling can disrupt critical processes and lead to system instability.
4. Modify entries in device-status table: This operation needs to be privileged because it is closely
related to the management of hardware devices. Unauthorized modifications could disrupt device com-
munication and system operation.
5. Access I/O device: Accessing I/O devices, such as reading or writing to them, should be privileged
to ensure that the operating system can control and manage these interactions effectively. Unauthorized
access could lead to hardware errors and data corruption.
Conversely, the following instructions can typically be performed in user mode:
•Read the clock: Reading the system clock is a non-privileged operation, allowing user-level programs
to obtain the current time without compromising system security or stability.
•Issue a trap instruction: This instruction can be initiated by user-level programs, but the actual
handling of traps and exceptions is done in the kernel mode, ensuring that system resources are protected.
•Switch from user to kernel mode: While the act of switching modes itself is privileged, user programs
can request a mode switch through a trap instruction. However, the kernel manages and controls this
transition to protect system resources.
Understanding which instructions require privilege is fundamental for maintaining the security and stability
of an operating system, as it ensures that critical system resources are managed and protected appropriately.
1

2 2nd Q&A
2.1 Question
We have stressed the need for an operating system to make efficient use of the computing
hardware. When is it appropriate for the operating system to forsake this principle and to
“waste” resources? Why is such a system not really wasteful?
2.2 Answer
In the realm of operating systems, efficiency in utilizing computing hardware is a fundamental principle.
However, there are instances when it becomes appropriate for the operating system to deviate from this
principle and appear to ”waste” resources. Surprisingly, such scenarios can actually be far from wasteful, and
here’s why.
Consider single-user systems where the primary focus is to enhance the user’s experience. In such cases,
the operating system should aim to maximize the system’s resources for the benefit of the user. This means
that even if certain operations, such as a Graphical User Interface (GUI), may seem to consume more CPU
cycles than necessary, they do so with a distinct purpose in mind.
A GUI, for instance, might appear to be using additional computing resources, but it serves to optimize
the user’s interaction with the system. By providing a visually intuitive interface, it simplifies complex tasks,
enhances user productivity, and creates a more user-friendly environment. In this context, the utilization of
seemingly ”wasted” CPU cycles is justified by the substantial improvement in the user experience, making the
system far from wasteful.
Therefore, in single-user systems, the priority is to enhance the user’s interaction and productivity, and in
doing so, some resource utilization that might initially appear inefficient serves a valuable purpose in improving
the overall usability and functionality of the system.
3 3rd Q&A
3.1 Question
Give two reasons why caches are useful. What problems do they solve? What problems do they
cause? If a cache can be made as large as the device for which it is caching (for instance, a
cache as large as a disk), why not make it that large and eliminate the device?
3.2 Answer
Caches play a vital role in computer systems, offering several advantages as well as presenting specific chal-
lenges. Let’s delve into two key reasons why caches are invaluable, the issues they address, the potential
complications they introduce, and the rationale behind the size of caches concerning the devices they serve.
1. Enhancing Data Exchange and Resolving Speed Mismatches: Caches prove their worth in
scenarios where multiple system components need to exchange data, but they operate at differing speeds.
This is a common occurrence in computing systems where high-speed components, such as Central Processing
Units (CPUs), need to access data stored in slower components, like main memory. Caches effectively resolve
this data transfer challenge by acting as intermediate buffers with a moderate speed. When a faster device,
like a CPU, finds the required data in the cache, it can retrieve it promptly without having to wait for the
slower device. This results in a significant boost to system performance and overall responsiveness.
2. Data Consistency and Cache Management: While caches contribute to faster data retrieval, they
bring forth a critical concern related to data consistency. If data stored in the cache becomes outdated or is
modified within the slower component (e.g., main memory), the cache must be updated to ensure it reflects the
most current and accurate information. Maintaining data consistency, especially in multiprocessor systems
where multiple processes may concurrently access the same data, is a complex challenge that necessitates
sophisticated cache management techniques. Cache coherency protocols are employed to ensure that data
across all caches remains synchronized and up-to-date.
Regarding the question of whether a cache should be made as large as the device it is caching, the answer
isn’t straightforward. In theory, it might seem logical to create caches as large as the devices they serve, po-
tentially eliminating the need for the original devices altogether. However, this decision isn’t solely determined
by size. The ideal cache size depends on several factors, including the access patterns of applications, the cost
of memory, and the specific use case.
Moreover, caches may not fully replace devices for two primary reasons:
2

•Equivalent State-Saving Capacity: To consider replacing a component with a cache of the same size,
both the cache and the original component must have equivalent state-saving capacity. For instance, if
the original component retains its data even when power is removed (non-volatile storage), the cache
should also exhibit this characteristic.
•Affordability: Faster storage tends to be more expensive. Even if a cache could theoretically replace a
device, the cost of implementing an equally large cache could be prohibitively high, making it economi-
cally impractical. Therefore, the decision to eliminate a component in favor of a cache should carefully
weigh both technical and economic considerations.
4 4th Q&A
4.1 Question
Rank the following storage systems from slowest to fastest:
1. (a) Hard-disk drives
2. (b) Registers
3. (c) Optical disk
4. (d) Main memory
5. (e) Nonvolatile memory
6. (f) Magnetic tapes
7. (g) Cache
4.2 Answer
Below is the ranking of the indicated storage systems from slowest to fastest:
1. Magnetic Tapes (f ): Magnetic tapes are typically the slowest storage medium on this list. They
involve sequential access and have relatively slow read/write speeds.
2. Hard-Disk Drives (a): Hard-disk drives are faster than magnetic tapes but are slower compared to
other options. They offer random access but have mechanical components that affect speed.
3. Optical Disk (c): Optical disks, such as DVDs and CDs, are generally slower than hard-disk drives.
They rely on optical technology for data access.
4. Nonvolatile Memory (e): Nonvolatile memory, like NAND flash memory used in Solid-State Drives
(SSDs) and USB drives, is faster than traditional hard-disk drives. It offers fast random access with no
moving parts.
5. Main Memory (d): Main memory, also known as RAM (Random Access Memory), is significantly
faster than the aforementioned storage systems. It provides high-speed random access to store and
retrieve data that is actively used by the CPU.
6. Cache (g): Cache is a small but very high-speed memory located close to the CPU. It is designed for
ultra-fast data access and is faster than main memory.
7. Registers (b): Registers are the fastest storage in a computer system. They are directly built into the
CPU and provide the quickest possible access to data. Registers are used for immediate storage of data
during CPU operations.
5 5th Q&A
5.1 Question
Describe some of the challenges of designing operating systems for mobile devices compared
with designing operating systems for traditional PCs.
3

5.2 Answer
Designing operating systems for mobile devices presents several unique challenges compared to traditional
PCs. Here are some of the key challenges:
1. Limited Resources: Mobile devices, such as smartphones and tablets, have limited resources in terms
of processing power, memory, and storage. Operating systems for these devices must be highly resource-efficient
to run smoothly on hardware with constraints.
2. Variety of Hardware: Unlike traditional PCs, which often have a more standardized set of hardware
components, mobile devices come in various shapes and sizes from different manufacturers. This diversity in
hardware requires the operating system to support a wide range of devices, making device compatibility and
driver management more complex.
3. Power Efficiency: Mobile devices rely on battery power, so power efficiency is paramount. Operating
systems must be optimized to minimize power consumption, which involves managing CPU usage, background
processes, and screen brightness, among other factors.
4. Touchscreen and Gesture Support: Mobile devices primarily use touchscreen interfaces and ges-
tures. The operating system must provide a responsive and intuitive touch experience, including support for
gestures, multi-touch, and virtual keyboards.
5. Connectivity and Mobility: Mobile devices are constantly on the move and rely on various network
connections (cellular, Wi-Fi, Bluetooth, etc.). The operating system must seamlessly handle network switching,
maintain data connections, and prioritize data usage for the best user experience.
6. Security and Privacy: Mobile devices often store sensitive personal information and are more sus-
ceptible to physical theft or loss. Security measures, such as encryption, remote wipe capabilities, and app
sandboxing, are crucial in mobile OS design. Privacy concerns also require strict control over app permissions
and data access.
7. App Ecosystem: Mobile devices heavily rely on app stores and a diverse ecosystem of third-party
applications. The OS must support app distribution, security vetting, and app updates while maintaining
compatibility with a broad range of software.
8. User Experience: Designing an intuitive and user-friendly interface is critical for mobile devices.
The OS should provide a seamless and consistent user experience, including responsive performance, ease of
navigation, and compatibility with various screen sizes.
9. Updates and Maintenance: Operating systems for mobile devices need to support over-the-air
updates, ensuring that security patches and new features can be delivered efficiently to a wide range of
devices.
10. Multi-Tasking: Managing multitasking on mobile devices is different from traditional PCs. Operating
systems must efficiently handle background processes, switching between apps, and managing limited memory
resources.
11. Internationalization and Localization: Mobile devices are used worldwide, requiring support
for various languages, character sets, and cultural preferences. The OS must be capable of localization and
internationalization to cater to a global user base.
12. Regulatory and Carrier Restrictions: Mobile devices often need to comply with carrier-specific
requirements and regulations, adding complexity to the OS design and sometimes limiting functionality.
13. Form Factor Challenges: The diversity of mobile device form factors, including foldable phones and
wearable technology, introduces new challenges for user interface design and app compatibility.
In summary, designing operating systems for mobile devices demands a unique set of considerations and
solutions to address resource constraints, power efficiency, diverse hardware, and the demand for a seamless
user experience in an increasingly mobile world.
4

6 6th Q&A
6.1 Question
What is the main difficulty that a programmer must overcome in writing an operating system
for a real-time environment?
6.2 Answer
Writing an operating system for a real-time environment presents a primary challenge that demands meticulous
attention and intricate solutions. The key obstacle revolves around adhering to strict temporal constraints
within a real-time system. If the operating system fails to accomplish a task within its designated time frame,
it can lead to catastrophic consequences, potentially causing a system-wide failure. Thus, when embarking
on the development of an operating system for a real-time environment, the programmer must be acutely
aware of the criticality of ensuring that scheduling schemes and task execution are meticulously orchestrated
to prevent any breach of response time that exceeds the prescribed temporal boundaries. This entails intricate
management of tasks and resources to guarantee not only efficient operation but also unwavering compliance
with the stringent time constraints inherent in real-time systems. The gravity of this challenge cannot be
overstated, as the integrity and reliability of the entire system depend on this precise temporal coordination.
7 7th Q&A
7.1 Question
Timers could be used to compute the current time. Provide a short description of how this
could be accomplished.
7.2 Answer
You can effectively determine the current time in a program by utilizing timer interrupts. Here’s a method
to achieve this: The program can establish a timer for a specific duration into the future and then enter a
sleep mode. When a timer interrupt occurs and awakens the program, it can increment a counter in its local
state that keeps track of the number of interrupts received. This process can be repeated, with the program
continually setting timer interrupts and updating its local state whenever the interrupts are triggered. By
accumulating the count of interrupts and considering the elapsed time, the program can compute the current
time with a high level of accuracy.
8 8th Q&A
8.1 Question
Some early computers protected the operating system by placing it in a memory partition that
could not be modified by either the user job or the operating system itself. Describe two
difficulties that you think could arise with such a scheme
8.2 Answer
Implementing a security measure where the operating system is housed in a memory partition immune to
modification by both user processes and the operating system poses certain challenges. Here are two notable
difficulties that could potentially arise:
1. Data Exposure: Placing the operating system in a protected memory partition implies that certain
critical data, such as passwords, access control settings, and accounting information, would need to reside
in or pass through unprotected memory regions. This exposure to unprotected memory could make
this sensitive information accessible to unauthorized users or malicious processes, potentially leading to
security breaches and data compromises. It becomes a delicate balance between securing the OS and
ensuring the confidentiality of critical system data.
2. Limited System Flexibility: This scheme might restrict the flexibility and adaptability of the oper-
ating system. The separation of the OS from the rest of the system can make it challenging to update or
modify the operating system itself. This limitation can hinder the ability to implement patches, updates,
5

or improvements to the OS, which are essential for addressing security vulnerabilities or enhancing sys-
tem functionality. Furthermore, it might also impede the development of user applications that require
interactions with the operating system, limiting the system’s overall utility.
These difficulties highlight the trade-offs involved in implementing such a protective scheme and emphasize
the importance of finding a balance between security and system functionality in computer design.
9 9th Q&A
9.1 Question
Keeping in mind the various definitions of an operating system, consider whether the operating
system should include applications such as web browsers and mail programs. Argue both that
it should and that it should not, and support your answers.
9.2 Answer
Considering the diverse interpretations of what constitutes an operating system, the question arises as to
whether applications like web browsers and mail programs should be integrated into the operating system.
This debate revolves around two contrasting viewpoints, each with its set of arguments.
In Favor of Integration: Supporters of embedding popular applications within the operating system
argue that such inclusion can yield performance advantages. When applications are tightly coupled with the
operating system, they can harness kernel-level features more effectively. This integration allows for improved
efficiency and responsiveness since the application operates within the same framework as the operating system,
potentially resulting in better resource management and system resource utilization.
Against Integration: Conversely, there are compelling arguments against incorporating applications into
the operating system. These objections tend to carry more weight in this debate.
1. Applications Are Applications: The fundamental premise is that applications are distinct entities
from operating systems. The role of an operating system is to manage hardware resources, provide a
platform for software execution, and maintain system integrity. Applications, on the other hand, are
designed to fulfill specific user tasks. Combining the two can blur the lines and introduce complexity in
terms of system management and maintenance.
2. Security Concerns: Integrating applications within the operating system can lead to security vulnera-
bilities. Any security flaw in the integrated application can potentially compromise the entire operating
system, making it more challenging to safeguard the system against threats. This vulnerability outweighs
the potential performance advantages.
3. Bloatware: Embedding a multitude of applications within the operating system can lead to a bloated
and unwieldy system. A larger, more complex operating system can consume more resources, impacting
overall system performance and making it less efficient.
In conclusion, while there are arguments for integrating applications with the operating system based
on potential performance benefits, the prevailing arguments against this practice, including maintaining the
conceptual distinction between the two, addressing security concerns, and avoiding system bloat, make a com-
pelling case for keeping operating systems separate from user applications. The debate ultimately underscores
the importance of clear design principles and the need to strike a balance between performance and system
integrity.
6

10 10th Q&A
10.1 Question
Can we assume that a P2P computing environment is somehow also a client-server one? Bring
reasons to support your answer.
10.2 Answer
A Peer-to-Peer (P2P) computing environment and a Client-Server computing environment are distinct ar-
chitectural models with some fundamental differences. However, it is possible for a P2P environment to
incorporate elements of a client-server model under certain circumstances. Here are some reasons to support
the idea that a P2P computing environment can, to some extent, also be considered a client-server one:
1. Hybrid Architectures: Some P2P systems employ hybrid architectures that combine P2P and client-
server elements. In these cases, certain nodes in the P2P network may take on client-like roles when
accessing resources from other nodes that act as servers. This duality allows for the sharing of resources
and data in a more organized and controlled manner.
2. Centralized Services: In many P2P systems, there are centralized components or services that resem-
ble servers. These components facilitate functions like bootstrapping, discovery, or coordination within
the P2P network. While these components may not be traditional client-server servers, they perform
server-like roles by assisting in network management and resource lookup.
3. Resource Discovery: In a P2P environment, nodes may utilize a server-like entity to facilitate resource
discovery. These entities maintain indexes or directories of available resources and help nodes locate the
resources they need. This resource discovery mechanism resembles the way clients request information
from servers in a client-server architecture.
4. Hierarchical P2P Architectures: Some P2P systems introduce hierarchy, where certain nodes have
more control or authority over the network. These nodes can be seen as servers, providing specific
services and coordination functions to the more peer-like nodes. This hierarchical structure introduces
server-like elements into the P2P model.
5. Control and Security: In scenarios where certain nodes need more control over data or require
enhanced security, they may take on server-like roles within the P2P network. These nodes can enforce
access control, data validation, and other server-related tasks.
It’s important to note that while P2P environments can incorporate elements of client-server interactions,
the core philosophy of P2P is decentralized and peer-driven, where nodes have equal status and contribute
resources. The level of client-server interaction in a P2P system can vary greatly, and the extent to which it
resembles a traditional client-server model depends on the specific design and purpose of the P2P network.
7

11 11th Q&A
11.1 Question
When does a trap interrupt occur? complete your explanation with examples.
11.2 Answer
A trap interrupt, also known as a software interrupt or a system call, occurs when a program intentionally
requests a service or operation from the operating system, transitioning from user mode to kernel mode in a
controlled manner. Trap interrupts are typically initiated through the execution of a specific instruction or
system call, and they allow user programs to interact with the operating system to perform privileged tasks.
Here are a few examples to illustrate when a trap interrupt occurs:
1. File I/O Operations: When a user program needs to read or write data to a file, it typically cannot
do so directly because it lacks the necessary privileges. Instead, it issues a system call, such as open(),
read(), or write(), to request the operating system’s assistance. These system calls trigger trap
interrupts, enabling the operating system to perform the file I/O operations on behalf of the user program.
2. Process Management: If a user program wants to create a new process or terminate an existing one,
it uses system calls like fork(),exec(), or exit(). These system calls result in trap interrupts, allowing
the operating system to manage processes by allocating resources, creating new process structures, or
terminating processes as needed.
3. Memory Management: User programs cannot directly allocate or deallocate memory in the system’s
physical memory. System calls such as malloc() or free() trigger trap interrupts, permitting the
operating system to handle memory allocation and deallocation on behalf of the program.
4. Hardware Access: Access to hardware devices often requires privileged access. When a program needs
to interact with a hardware device, it uses system calls or special instructions. For example, sending
data to a printer or reading from a network card requires the user program to request assistance from
the operating system through trap interrupts.
5. Synchronization and Communication: System calls like sem wait() and sem post() for managing
semaphores or inter-process communication mechanisms such as message passing or shared memory rely
on trap interrupts to coordinate access and synchronization between different processes.
In each of these examples, a user program initiates a trap interrupt by invoking a system call or a specific
instruction that requires a privileged operation. The operating system then takes control, verifies the request,
performs the required action, and returns control to the user program. This mechanism ensures that user
programs cannot directly access privileged resources or perform operations that could compromise system
stability and security.
8

12 12th Q&A
12.1 Question
What’s a firmware? and how is it different from a software?
12.2 Answer
Firmware is a type of software that is specifically designed to be embedded into a hardware device. It resides
on non-volatile memory chips, which are typically soldered or somehow permanently attached to a device’s
motherboard. Firmware is responsible for controlling the functionality and behavior of the hardware it is
associated with. It serves as an intermediary between the hardware and higher-level software, facilitating
communication and enabling the hardware to perform its intended functions. Here are key characteristics and
differences between firmware and software:
1. Hardware Integration: Firmware is intimately tied to the hardware it controls. It is closely integrated
with the device’s physical components and is often stored on microcontrollers or read-only memory
(ROM) chips.
2. Persistence: Firmware is non-volatile, meaning it retains its code and data even when the device is
powered off or rebooted. This is in contrast to traditional software, which is typically stored on storage
media and loaded into volatile memory (RAM) when the program is run.
3. Functionality: Firmware’s primary role is to provide low-level control and management of hardware
components. It initializes and configures hardware devices, ensuring they work as intended. Firmware can
be found in a wide range of devices, including computer peripherals (e.g., printer firmware), embedded
systems (e.g., microwave oven controllers), and even in hardware like smartphones (e.g., smartphone
baseband firmware).
4. Updates: Firmware updates are less frequent than software updates and usually require a different
process. They may involve reflashing the firmware on a device, which can be a complex and sometimes
risky procedure.
5. Less User Interaction: Users generally do not interact directly with firmware. Firmware’s functions
are typically transparent to the end user. Firmware updates are usually initiated and managed by the
device manufacturer or service technicians.
Software, on the other hand, is a more general term that encompasses a wide range of computer programs
and applications. Software can include operating systems, application software, games, and much more. Unlike
firmware, software is typically stored on external storage devices like hard drives, solid-state drives, or in the
cloud, and it is loaded into the computer’s volatile memory (RAM) when it is executed. Software runs on top
of the operating system and interacts with users and other software applications. It can be easily updated,
and users often have control over installing, updating, and configuring software on their devices.
In summary, firmware is a specialized type of software that is closely tied to a specific hardware device,
while software encompasses a broader range of programs that run on general-purpose computing platforms.
Firmware is essential for the proper functioning of hardware, while software provides user-facing functionality
and can be easily updated and replaced.
9