Operating Systems Practice Quiz: Advanced OS Theory

The kernel is the central component of an operating system that manages various resources and processes. One of the key tasks of the kernel is to keep track of bookkeeping information about processes. This information includes important details such as the program counter, which keeps track of the next instruction to be executed in a process. Therefore, the statement that the kernel uses the Process Control Block to keep track of bookkeeping information about processes, including the program counter, is true.

This statement is true because one of the conditions necessary for deadlock is when a process acquires a resource and holds onto it while it tries to acquire other resources. This can lead to a situation where multiple processes are waiting for each other's resources, causing a deadlock.

In a base-and-bounds model, the base is used to determine the starting address of a segment or module in memory. It provides the reference point from which the memory allocation for the segment begins. Therefore, the statement that the base tells where a segment is loaded in memory is true.

It is true that every I/O device typically has a waiting queue associated with it. This waiting queue is used to manage and prioritize the incoming requests from different processes or users. When a process or user makes a request to an I/O device, it is added to the waiting queue until the device becomes available to serve the request. This ensures that the requests are handled in a fair and orderly manner, preventing any process or user from monopolizing the device's resources.

This statement is true because evaluating a scheduling algorithm using a script that creates a predefined mix of jobs and tracking statistics about the algorithm's performance allows for a systematic and objective assessment of its effectiveness. By analyzing the data collected from the script, one can determine how well the algorithm handles different job scenarios and make informed decisions about its suitability for specific applications. This approach helps in identifying any potential flaws or areas of improvement in the scheduling algorithm.

In a base-and-bounds model, the base value indicates the starting address in memory where a segment or module is loaded. This value is used to calculate the actual memory address for each instruction or data access within the segment. Therefore, the statement "the base tells where a segment is loaded in memory" is true.

A segmented memory model is a memory management technique where the memory is divided into segments, allowing for the separation of code and data. This separation is beneficial as it helps in organizing and managing the memory efficiently. Code segments contain instructions that the processor executes, while data segments store variables and data used by the program. By separating code from data, it becomes easier to maintain and modify the program, as well as protect the code from unauthorized access or modification. Therefore, the statement "A segmented memory model is good for separating code from data" is true.

An inverted page table needs to be searched on each page reference in order to translate virtual addresses to physical addresses. Organizing it as a hash table allows for efficient searching, as the hash function can quickly locate the desired page entry. This helps to improve the overall performance of the system by reducing the time taken for address translation.

The medium-term scheduler's job is to suspend jobs if the system is under heavy load. This is true because the medium-term scheduler is responsible for managing the degree of multiprogramming in the system. If the system is under heavy load, suspending jobs can help alleviate the load and improve overall system performance. By suspending jobs, the medium-term scheduler can prioritize and manage the execution of processes, ensuring that the system operates efficiently and effectively.

When a new process is forked in UNIX, it retains access to the parent's open files. This means that the child process created through forking will have the same open files as the parent process. This allows the child process to read from or write to the same files that the parent process has open, providing a way for communication and sharing of data between the parent and child processes.

Threads in a program can access and modify global memory by default. Global memory is a shared memory space that is accessible by all threads in a program. This allows threads to communicate and share data with each other. Therefore, the given statement "By default, threads share global memory" is true.

In the working set model, the balance set refers to the set of pages that are currently in use by a process. Thrashing occurs when the system is constantly swapping pages in and out of memory, which can significantly degrade performance. If the balance set is exceeded, it means that the number of pages required by the process exceeds the available memory, leading to frequent page faults and excessive disk I/O. Therefore, it is true that exceeding the balance set in the working set model can result in thrashing.

A system that uses segmentation and paging does indeed mean that the pages are grouped into logical segments. Segmentation involves dividing the memory into logical segments such as code segment, data segment, and stack segment, while paging involves dividing the memory into fixed-size pages. This combination allows for efficient memory management and access control in operating systems. Therefore, the statement is true.

The optimal (Min) page placement algorithm is not used in practice because it relies on accurately predicting future page references. This means that the algorithm would need to know in advance which pages will be accessed in the future, which is not possible in real-world scenarios. Instead, other algorithms such as the Least Recently Used (LRU) or First-In-First-Out (FIFO) algorithms are used, which make decisions based on past page references rather than future predictions.

Run time binding is used for Microsoft Dynamic link libraries. This means that the binding between the function call and the function definition happens at runtime, allowing the program to access the functions in the DLL dynamically. This enables flexibility and the ability to load and use functions from DLLs as needed during program execution. Therefore, the given statement is true.

In a non-distributed system, deadlock is rare because it occurs when multiple processes are unable to proceed because each is waiting for a resource that another process holds. In a non-distributed system, there is usually a single central processing unit (CPU) and a limited number of resources. Therefore, the chances of multiple processes getting into a deadlock situation are low. As a result, most non-distributed systems do not prioritize detecting and resolving deadlocks, hence they ignore them.

The medium-term scheduler is responsible for managing the movement of processes between main memory and secondary storage. It is invoked during times of high resource contention, such as when physical memory is full. This scheduler helps in freeing up memory by swapping out some processes to the secondary storage, allowing other processes to be loaded into memory. Therefore, the given statement is true.

A paging scheme does not suffer from external fragmentation because it divides the memory into fixed-sized pages and allocates memory to processes in these fixed-sized units. This eliminates the problem of external fragmentation where free memory blocks are scattered throughout the memory, making it difficult to allocate contiguous blocks of memory to processes. With paging, each process can be allocated non-contiguous pages, allowing for efficient memory allocation and utilization.

The statement is false because virtual memory space can be larger than physical memory space. Virtual memory is a technique used by operating systems to extend the available memory beyond the physical memory. It allows programs to use more memory than is physically available by temporarily storing data in the hard disk. Therefore, the virtual memory space can be larger than the physical memory space.

The statement is false because killing the process in a deadlock is not always the best solution. Deadlocks occur when two or more processes are unable to proceed because each is waiting for a resource held by the other. Killing a process in a deadlock may not resolve the issue and can result in loss of data or system instability. Instead, the operating system should use techniques such as resource preemption or process termination to resolve the deadlock.

Systematic multiprocessing does not use one core to handle the scheduling for all the other cores in multicore systems. In fact, systematic multiprocessing involves distributing the workload across multiple cores, with each core having its own scheduler to handle its own tasks. This allows for better utilization of resources and improved performance in multicore systems.

The statement is false because an OS designer cannot simply pick a new page size. The page size is a fundamental aspect of the operating system and changing it requires significant modifications to the memory management system. The page size affects various aspects of the system's performance, including memory utilization and disk I/O. Therefore, changing the page size is a complex decision that involves careful analysis and consideration of various factors.

The statement is false because killing the process holding the most resources in a deadlock may not always be the best solution. It can lead to loss of important data or disruption of critical tasks. Instead, the OS should use techniques like resource preemption, where resources are temporarily taken away from a process to break the deadlock and allow other processes to progress. Killing a process should be the last resort when all other options have been exhausted.

Symmetric multiprocessing (SMP) is a type of multiprocessing where each processor in the system performs the same tasks and has equal access to resources. In SMP systems, the scheduling of tasks is typically distributed among all the available cores, rather than being handled by a single core. Therefore, the given statement is false as SMP does not use one core to handle scheduling for all other cores, but rather distributes the scheduling among all the cores in the system.

Data skewness is a statistical measure used to quantify the asymmetry or lack of symmetry in the distribution of data points within a dataset. It indicates whether the data is evenly distributed around the mean or if it is skewed towards one end of the distribution. A positively skewed dataset has a longer tail on the right side, while a negatively skewed dataset has a longer tail on the left side. Understanding data skewness is crucial for analyzing the shape and characteristics of a dataset, as it provides insights into the distribution's behavior and potential outliers.

Using a larger page size does not necessarily make page tables larger. Page tables are data structures used by the operating system to map virtual memory addresses to physical memory addresses. The size of the page tables depends on the total amount of virtual memory in use, not on the page size. Increasing the page size can actually reduce the size of the page tables, as larger pages require fewer entries in the tables to cover the same amount of memory. Therefore, the statement is false.

Virtual memory is a memory management technique that allows a computer to compensate for the limited physical memory by temporarily transferring data from the RAM to the hard disk. In this technique, the virtual memory space is divided into pages, and the physical memory is divided into frames. The virtual memory space can be larger than the physical memory space, but it is not always the case. The size of the virtual memory depends on the system's architecture and the operating system's settings. Therefore, the statement that virtual memory space is always bigger than physical memory space is false.

User processes do not have the ability to shut off interrupts. Interrupts are a mechanism used by the operating system to handle events and perform tasks in a timely manner. They can only be controlled by the operating system and are essential for managing hardware devices and handling critical events. Therefore, the statement that interrupts can be shut off by user processes is false.

The statement suggests that there is only one I/O queue for the system, which is not true. In most computer systems, there are multiple I/O queues to handle different types of input/output operations. This allows for better organization and prioritization of tasks, improving overall system performance and efficiency.

The statement is false because the linker is responsible for resolving external references and symbols in a program, not addresses. The compiler is responsible for generating the machine code and assigning addresses to instructions and data. The linker then links different object files together and resolves any unresolved symbols.

Segmentation does not avoid external memory fragmentation. In fact, segmentation can lead to external fragmentation as it allocates memory in variable-sized segments. This can result in small gaps of unused memory between segments, making it difficult to allocate contiguous blocks of memory for new processes. To avoid external fragmentation, techniques like paging are used, which divide memory into fixed-sized blocks.

When compiling a code module, an error is not reported when the compiler cannot resolve the address. Instead, the compiler will report an error when it encounters syntax errors, semantic errors, or other issues that prevent it from properly compiling the code. The inability to resolve an address typically occurs at runtime, not during the compilation process. Therefore, the correct answer is false.

When compiling a code module, an error is not reported when a compiler cannot resolve an address. Instead, this type of error is known as a linker error, which occurs during the linking phase after the compilation process. The linker is responsible for resolving addresses and linking different modules together to create an executable program. Therefore, the correct answer is false.

In dual-mode processing, a user process does not perform I/O by accessing the I/O device directly. Instead, it makes requests to the operating system, which then handles the I/O operations on behalf of the user process. This is done to ensure security and prevent unauthorized access to the I/O devices. Therefore, the statement that a user process does I/O by accessing the I/O device directly is false.

The second chance cyclic algorithm does not select the oldest page as its victim. Instead, it selects the page that has been in memory the longest without being referenced. This algorithm uses a circular queue to keep track of the order in which pages are referenced, and when a page is referenced, its reference bit is set to 1. The algorithm starts at the front of the queue and checks the reference bit of each page. If the reference bit is 0, the page is considered a victim and is replaced. If the reference bit is 1, the reference bit is set to 0 and the page is moved to the back of the queue. Therefore, the algorithm does not solely rely on the age of the page to determine the victim.

In the remote procedure call (RPC) paradigm, data is actually translated even if the client and the server are running on the same architecture and using the same operation. This is because RPC allows communication between different systems with potentially different architectures and data representations. Therefore, data translation is necessary to ensure compatibility and proper communication between the client and server.

In Java RMI, data does not need to be translated between the caller and the callee. Java RMI handles the translation of data automatically, allowing objects to be passed between different Java Virtual Machines (JVMs) without the need for manual translation or serialization. This simplifies the process of remote method invocation and makes it easier for developers to work with distributed systems in Java.

An inverted page table does not keep track of one entry per virtual page per process. Instead, it keeps track of one entry per physical page frame. This table is used to map each physical page frame to the corresponding virtual page, allowing for efficient memory management and address translation. Therefore, the correct answer is false.

Kernel level threads, also known as kernel threads or lightweight processes, are managed by the operating system kernel. Unlike user-level threads, kernel level threads are visible to the operating system and can be scheduled independently. When a kernel level thread blocks while performing a system call, only that specific thread is blocked, not all the threads associated with the process. Therefore, the given statement is false.

In a microkernel architecture operating system, processes usually communicate using message passing rather than shared memory. This is because the microkernel approach aims to keep the kernel as small and simple as possible, delegating most functionalities to user-level processes. Message passing allows for better isolation and protection between processes, as they can only communicate through well-defined interfaces provided by the microkernel. Shared memory, on the other hand, introduces the risk of one process accessing or modifying the memory of another process directly, which goes against the principles of the microkernel design. Therefore, the statement is false.