Question 1

Computer graphics windowing: In raster graphics, “scissoring” (clipping to a rectangular window) enables which type of display behavior?

Accepted Answer

Introduction / Context: Scissoring, often called rectangular clipping, is a fundamental graphics operation. It restricts rendering to a specified window (region) so that primitives outside the window are not drawn. This is used in GUI toolkits, game engines, and visualization pipelines to optimize and control drawing. Given Data / Assumptions: The display area supports a defined clipping rectangle. Graphics primitives can extend beyond the visible region. We want to know what scissoring enables with respect to what is shown. Concept / Approach: With scissoring, the pipeline discards fragments (or clamps primitives) lying outside a defined window, ensuring that only content intersecting the window is rendered. This results in partial display of the overall dataset when only a subset falls within the scissor rectangle. Step-by-Step Solution: Define a scissor rectangle in screen coordinates.Enable scissoring so that rendering is constrained to that rectangle.Submit geometry; only the intersection with the rectangle is rasterized/displayed.Observe that only part of the overall data appears—namely, what lies inside the window. Verification / Alternative check: In APIs (OpenGL, Direct3D, Vulkan), enabling the scissor test limits fragment processing to the specified rectangle, confirming partial display behavior. Why Other Options Are Wrong: “Entire data” or “full data on full screen” contradicts the clipping function. “No data” would require an empty window, not normal scissoring. Common Pitfalls: Confusing scissoring with viewport scaling; the viewport maps coordinates, while scissoring filters pixels to a region. Final Answer: a part of data to be displayed

Question 2

Operating systems — Multilevel feedback queues:  In CPU scheduling, what is the main characteristic of a multilevel feedback queue (MLFQ) scheduler, often informally called a “feedback queue”?

Accepted Answer

Introduction / Context: Multilevel feedback queue (MLFQ) scheduling is a classic operating-system technique that adapts CPU allocation based on how processes behave. It is widely taught because it illustrates responsive time-sharing and priority aging without manual tuning once configured. Given Data / Assumptions: The question refers to “feedback queue,” i.e., multilevel feedback queues (MLFQ). MLFQ typically uses several ready queues with different priorities and time quanta. Processes may move between queues based on observed execution behavior (CPU burst length, I/O wait). Concept / Approach: MLFQ adapts priorities dynamically. Interactive or I/O-bound tasks that frequently yield the CPU are rewarded with higher priority and shorter quanta to improve responsiveness. CPU-bound tasks that use their full quantum are gradually demoted to lower-priority queues, receiving longer quanta but less frequent dispatch. Thus, the scheduler “dispatches according to execution characteristics.” Step-by-Step Solution: Identify that a feedback queue learns from a task’s recent CPU usage.Recognize that tasks move up/down queues based on behavior (feedback).Conclude that dispatching reflects execution characteristics, not manual intervention.Select the option that states this adaptive dispatching behavior. Verification / Alternative check: Standard OS texts describe MLFQ rules: if a job uses up its quantum, move it to a lower-priority queue; if it yields early or waits for I/O, move it up. This is precisely dispatching by execution characteristics. Why Other Options Are Wrong: Very easy to implement: MLFQ is more complex than single-queue algorithms. Used to favor real-time tasks: real-time needs dedicated policies (e.g., rate monotonic, EDF). Require manual intervention: MLFQ adapts automatically after initial configuration. Common Pitfalls: Confusing MLFQ with fixed multilevel queues (no feedback). Assuming it is primarily a real-time scheduler rather than a general-purpose, interactive one. Final Answer: dispatch tasks according to execution characteristics

Question 3

Memory management fundamentals:  In memory systems, what is the purpose of boundary (base and limit) registers maintained by the operating system/hardware?

Accepted Answer

Introduction / Context: Protecting processes from one another is a core responsibility of an operating system. Base and limit (boundary) registers are a classic hardware support mechanism for relocation and protection in simple memory-management schemes. Given Data / Assumptions: Boundary registers typically include a base (start physical address) and a limit (size or end address). They are checked on each memory reference. The goal is process isolation and prevention of illegal memory access. Concept / Approach: When a program accesses memory, the effective address = base + logical address. The hardware compares the logical address against the limit to ensure it is within the program’s assigned region. Thus, these registers effectively mark the beginning and ending boundaries of a program’s memory region. Step-by-Step Solution: Identify that “boundary registers” refers to base and limit registers.Understand that base gives the start address; limit encodes the range.These define the legal memory interval for a process.Therefore, they track the beginning and ending of programs. Verification / Alternative check: Intro OS texts show diagrams with base/limit protecting a contiguous segment per process; any reference outside the range triggers a trap. Why Other Options Are Wrong: Temporary variable storage: handled in RAM/stack, not special registers. Only necessary with fixed partitions: also used with dynamic partitions and simple MMUs. Track page boundaries: paging uses page tables, not base/limit alone. Common Pitfalls: Confusing segmentation/paging with base-limit protection; assuming boundary registers store actual program data rather than address bounds. Final Answer: track the beginning and ending of programs

Question 4

Core system software:  What is the name of the system that deals with running the actual computer (resource management, scheduling, I/O) rather than solving programming problems directly?

Accepted Answer

Introduction / Context: An operating system (OS) abstracts hardware and manages resources so applications can run safely and efficiently. It is distinct from application programs or source/object code artifacts produced by compilers. Given Data / Assumptions: We focus on software that manages CPU, memory, devices, and files. It provides services (system calls), security, and scheduling. It is not a particular application solving a business or algorithmic problem. Concept / Approach: The OS coordinates the computer’s operation, offering a platform for application programs. It runs privileged code, handles interrupts, and enforces isolation. Hence, among listed terms, “Operating system” best names the system that runs the computer. Step-by-Step Solution: Identify the component responsible for running the computer: OS.Distinguish from “source/object program” (artifacts of compilation).Note “systems program” is a broader category that can include OS utilities, but not necessarily the kernel and core resource manager itself.Choose “Operating system.” Verification / Alternative check: Standard computing definitions place process management, memory management, file systems, and device drivers under the OS umbrella. Why Other Options Are Wrong: Systems program: generic term; could be compilers or linkers. Object program and Source program: program code artifacts, not the manager. Common Pitfalls: Equating “systems programming” tools with the OS itself; forgetting that OS includes kernel plus essential services. Final Answer: Operating system

Question 5

Process scheduling basics:  Within the process scheduler, what is the primary function of the dispatcher component?

Accepted Answer

Introduction / Context: The scheduler decides which process should run; the dispatcher performs the low-level mechanics of context switching so that decision takes effect. Understanding this separation clarifies how operating systems multiplex the CPU among tasks. Given Data / Assumptions: A ready queue exists with runnable processes/threads. The scheduler has chosen the next process. The dispatcher will enact that choice. Concept / Approach: The dispatcher saves the state of the current process, loads the state of the chosen ready process (registers, program counter), switches to user mode, and transfers control. It may also handle TLB or address space changes. Thus, its core duty is to assign the ready process to the CPU by performing the context switch. Step-by-Step Solution: Recognize that swapping and memory loads are long-latency I/O activities.Identify the dispatcher as the quick, CPU-centric context switch unit.Match this to “assigning ready process to the CPU.”Select that option as correct. Verification / Alternative check: OS documentation separates long-term/medium-term scheduling from short-term dispatching; the dispatcher executes the scheduling decision immediately. Why Other Options Are Wrong: Swapping/bringing processes to memory: done by memory manager or medium-term scheduler. Suspending due to load: a policy decision, not the dispatcher’s core role. Common Pitfalls: Conflating scheduler and dispatcher; assuming the dispatcher manages paging or swapping (it does not). Final Answer: assigning ready process to the CPU

Question 6

Compiler diagnostics:  Which class of errors can a compiler reliably detect and report during translation of a source program?

Accepted Answer

Introduction / Context: Compilers analyze source code to transform it into object code. Along the way, they validate program structure. Understanding what a compiler can and cannot detect helps developers interpret error messages and design tests. Given Data / Assumptions: We distinguish syntax, semantic, and logical errors. Syntax concerns grammar of the language (tokens, statements). Semantic concerns meaning (types, declarations, compatibility). Concept / Approach: All compilers detect syntax errors because parsing requires the program to adhere to grammar rules. Many compilers also detect numerous semantic errors (e.g., type mismatches, undeclared identifiers). Logical errors (algorithmic mistakes) typically compile fine but produce wrong results at runtime. The safest, universally correct answer is that compilers detect syntax errors. Step-by-Step Solution: Identify the universally detectable class: syntax errors.Note that semantic checks vary by language and compiler strictness.Logical errors are outside the compiler’s capability.Choose “Syntax errors.” Verification / Alternative check: Parsing fails immediately on grammar violations; compilers emit errors such as “expected ;” or “unexpected token.” Why Other Options Are Wrong: Semantic errors: often detected, but the question asks which errors the compiler can point out reliably; syntax is the baseline. Logical errors: require dynamic knowledge or specifications. Internal errors: refer to bugs in the compiler itself, not user code. Common Pitfalls: Assuming all meaning-related mistakes are caught at compile time; languages with dynamic typing defer many checks to runtime. Final Answer: Syntax errors

Question 7

Software categories:  What do we call the collection of all programs that make a computer usable by managing hardware and providing common services (as opposed to individual end-user applications)?

Accepted Answer

Introduction / Context: Software is broadly divided into system software and application software. System software operates the computer and provides a foundation on which applications run. Given Data / Assumptions: The question asks for the name describing the suite that makes a computer usable. Includes OS, device drivers, utilities, and system libraries. Excludes user-level applications such as word processors or games. Concept / Approach: System software comprises the operating system, boot loaders, drivers, shells, and essential utilities that collectively manage resources and expose APIs. This layer enables application portability and efficient hardware use. Step-by-Step Solution: Recognize that “makes the computer usable” points to the foundational layer.Identify that layer as system software.Distinguish from application software (end-user tasks) and shareware (licensing model).Select “System software.” Verification / Alternative check: Standard taxonomy: system software vs application software vs firmware. Firmware is persistent software embedded in hardware but is not the entire suite making a PC usable by itself. Why Other Options Are Wrong: Application software: consumes system services; does not manage the computer. Firm ware: misspelled “firmware” and refers to embedded code, not the full set. Shareware: a distribution model, not a software category by function. Common Pitfalls: Confusing firmware with operating systems; assuming bundled apps are part of the system layer. Final Answer: System software

Question 8

Deadlock conditions:  Four necessary conditions for deadlock are mutual exclusion, no-preemption, circular wait, and which additional condition?

Accepted Answer

Introduction / Context: Coffman’s conditions identify the four necessary prerequisites for a deadlock in resource allocation systems. Understanding them helps in designing prevention and avoidance strategies. Given Data / Assumptions: We already have mutual exclusion, no preemption, and circular wait. We seek the fourth condition. Resources are non-shareable and requested by processes over time. Concept / Approach: The four conditions are: mutual exclusion, hold and wait, no preemption, and circular wait. Hold and wait means processes currently holding resources also request additional resources and wait while holding what they already own—enabling circular dependency formation. Step-by-Step Solution: List known conditions.Recall the missing term is “hold and wait.”Confirm that this is indeed distinct from the other three.Choose “hold and wait.” Verification / Alternative check: Any OS text enumerates these four together. Breaking any one prevents deadlock; e.g., preventing hold-and-wait by forcing processes to request all resources at once. Why Other Options Are Wrong: Deadlock avoidance: a strategy, not a condition. Race around condition and buffer overflow: different classes of problems. Common Pitfalls: Confusing avoidance/prevention techniques with conditions; mixing runtime bugs (race/overflow) with resource-allocation theory. Final Answer: hold and wait

Question 9

Loaders — absolute loading scheme:  In an absolute loading scheme, which function is performed by the loader itself?

Accepted Answer

Introduction / Context: Loaders place object code into memory for execution. Different schemes (absolute, relocating, linking) assign different responsibilities to assemblers, linkers, and loaders. Given Data / Assumptions: We are specifically in an absolute loading scheme. Absolute object modules contain fixed, final addresses. No relocation or symbol resolution is required at load time. Concept / Approach: Under absolute loading, the assembler or linker has already resolved addresses. The loader’s job is simply to read the object code and place it at the specified memory locations, then transfer control. It does not perform relocation, allocation decisions, or linking at this stage. Step-by-Step Solution: Identify scheme: absolute loading (no relocation/linking).Determine the remaining role: copy code to memory and start execution.Therefore, the loader’s function is “Loading.”Select option “Loading.” Verification / Alternative check: Toolchain descriptions contrast absolute loaders with relocating loaders and linkers (which handle symbol resolution and relocation). Why Other Options Are Wrong: Reallocation/Allocation: placement decisions are pre-determined for absolute code. Linking: symbol resolution happens earlier. Common Pitfalls: Assuming all loaders relocate; in absolute loading, addresses are final, so relocation is unnecessary. Final Answer: Loading

Question 10

Device classes:  Which of the following is a block device (transferring data in fixed-size blocks rather than character streams)?

Accepted Answer

Introduction / Context: Operating systems distinguish between character devices (stream-oriented) and block devices (random-access, block-oriented). This affects buffering, caching, and I/O interfaces. Given Data / Assumptions: Character devices send/receive byte streams (e.g., keyboards, serial ports). Block devices read/write blocks with addressing (e.g., disks). We must choose which listed device is block-oriented. Concept / Approach: Disks are canonical block devices: the OS issues reads/writes for blocks identified by logical block numbers, enabling caching and random access. Peripherals like mice, printers, and terminals handle streams of characters or events and are treated as character devices. Step-by-Step Solution: Identify device characteristics of each option.Mouse/printer/terminal use streams or lines (character devices).Disk uses fixed-size blocks with random access.Select “disk.” Verification / Alternative check: UNIX device taxonomy (e.g., /dev/sdX as block, /dev/tty as character) exemplifies this distinction. Why Other Options Are Wrong: Mouse, printer, terminals: no block-addressable storage; stream-oriented. Common Pitfalls: Confusing printer spool files (which are stored on disks) with the printer device itself; thinking a terminal emulator’s scrollback implies block I/O—it does not. Final Answer: disk

Question 11

Input validation in information systems:  Which of the following checks cannot be carried out on input data supplied to a system?

Accepted Answer

Introduction / Context: Input validation ensures data quality, security, and correctness. Common validation techniques include syntax, range, and consistency checks before data is accepted into a system. Given Data / Assumptions: “Syntax check” validates format and pattern (e.g., date format, email pattern). “Range check” ensures numeric values fall within allowed limits. “Consistency check” compares related fields for logical coherence (e.g., start date before end date). Concept / Approach: All three types of checks are standard and widely implemented across applications, from form validation to database constraints and ETL pipelines. Therefore, none of these is “impossible to carry out.” Step-by-Step Solution: Evaluate each check for feasibility in typical systems.Confirm that syntax, range, and consistency checks are implementable.Since all are feasible, the answer to “which cannot be carried out?” is “None of the above.”Select “None of the above.” Verification / Alternative check: Industry standards (e.g., input validation guidance in secure coding) enumerate these checks as foundational controls. Why Other Options Are Wrong: Each individual check listed is possible and commonly used; “All of the above” would mean none can be done, which is false. Common Pitfalls: Assuming validation is limited to syntactic checks only; overlooking cross-field consistency rules that catch subtle errors. Final Answer: None of the above

Question 12

Semaphores in operating systems: Which statement best describes the primary purpose of semaphores when coordinating access to shared (critical) resources among concurrent processes/threads?

Accepted Answer

Introduction / Context: Semaphores are classic synchronization primitives used in operating systems and concurrent programming to coordinate access to shared data. They help ensure that only a safe number of processes or threads enter a critical section at once, thereby avoiding race conditions and data corruption. This question tests your understanding of the core purpose of semaphores. Given Data / Assumptions: Multiple processes or threads may attempt to access a shared resource. Critical sections require mutual exclusion to preserve correctness. Semaphore operations are atomic: wait (P/down) and signal (V/up). Concept / Approach: A binary semaphore (value 0 or 1) enforces mutual exclusion; a counting semaphore controls access to a limited resource with capacity greater than one. Their goal is to prevent contention (simultaneous, unsafe access), which in turn prevents race conditions. While semaphores can be used in protocols that avoid deadlocks, their mere presence does not automatically prevent all deadlocks—it depends on how they are used. Step-by-Step Solution: Recognize that contention over shared resources is the immediate problem semaphores address.Binary semaphores provide a lock-like mechanism to protect critical sections.Counting semaphores coordinate limited-capacity resources (for example, a pool size).Therefore, the best description is preventing contention and races, not guaranteeing deadlock freedom. Verification / Alternative check: Standard OS texts present semaphore-based mutual exclusion and producer–consumer solutions where contention is controlled by semaphore counters; deadlock avoidance requires additional policy (ordering, timeouts, or detection). Why Other Options Are Wrong: synchronize critical resources to prevent deadlock: Semaphores alone do not ensure deadlock freedom; design matters. are used to do I/O: Semaphores are not I/O mechanisms. are used for memory management: They are not allocation or paging tools. None of the above: Incorrect because preventing contention is correct. Common Pitfalls: Assuming semaphores automatically eliminate deadlock; forgetting to signal, which can cause starvation; using multiple semaphores in inconsistent order leading to deadlock. Final Answer: synchronize critical resources to prevent contention

Question 13

CPU sharing model: Which technique switches jobs so rapidly that each appears to have the computer to itself, thereby sharing processor time among several jobs?

Accepted Answer

Introduction / Context: Modern operating systems give the illusion that multiple applications run simultaneously on a single CPU by rapidly interleaving execution. This foundational concept underlies interactive computing and multi-user systems. The question asks for the name of this technique. Given Data / Assumptions: A single processor serves multiple jobs or users. Jobs are switched frequently in very small time slices. Users perceive responsiveness as if they had dedicated hardware. Concept / Approach: Time sharing divides CPU time into quanta (time slices). A scheduler allocates these quanta among runnable processes. Rapid context switching plus preemption creates an interactive illusion even with limited hardware. This is distinct from simple batch processing or first-in, first-out queues without preemption. Step-by-Step Solution: Identify the feature: rapid switching among active jobs.Map to OS terminology: time sharing with preemptive multitasking.Confirm that alternatives (time out, time domain, FIFO) do not match this defining behavior. Verification / Alternative check: Historical systems (e.g., early Unix on minicomputers) exemplify time-sharing, providing terminals with responsive sessions via preemptive scheduling and quanta. Why Other Options Are Wrong: time out: Refers to an expiration event, not CPU sharing. time domain: A signal-processing phrase, not a scheduling model. FIFO: A queue discipline; without preemption, it does not ensure interactive responsiveness. None of the above: Incorrect because time sharing is the established term. Common Pitfalls: Confusing cooperative multitasking (non-preemptive) with time sharing; assuming FIFO alone yields interactivity; ignoring the role of time quanta and preemption. Final Answer: time sharing

Question 14

Public-key cryptography concept: In a public key encryption system, who can successfully decode (decrypt) the transmitted data?

Accepted Answer

Introduction / Context: Public-key cryptography uses a key pair: a public key that can be shared openly and a private key that must be kept secret. Understanding who can decrypt ciphertext under this model is fundamental to secure communications and authentication on networks. Given Data / Assumptions: A sender encrypts data using the receiver’s public key. The receiver holds the corresponding private key securely. Only the matching private key can decrypt data encrypted by its paired public key. Concept / Approach: Asymmetric encryption ensures confidentiality: anyone can encrypt to a recipient using the recipient’s public key, but only the intended recipient can decrypt using their private key. This is distinct from digital signatures, where the sender uses a private key to sign and others use the public key to verify authenticity. Step-by-Step Solution: Identify goal: confidentiality of transmitted data.Encryption is performed with the receiver’s public key.Decryption requires the corresponding private key that only the correct receiver possesses.Therefore, only the correct receiver can decode the data. Verification / Alternative check: Standard protocols (e.g., hybrid schemes in TLS) rely on public-key operations for key exchange and confidentiality—only holders of the private key can complete decryption. Why Other Options Are Wrong: allows anyone to decode: False; that would defeat confidentiality. allows only the correct sender to decode: Decryption is for the receiver, not the sender. does not encode the data: Contradicts the premise of an encryption system. None of the above: Incorrect because the correct receiver is the right choice. Common Pitfalls: Confusing encryption (public key) with signatures (private key); assuming key pairs are interchangeable without directionality; ignoring key management and authenticity of public keys. Final Answer: allows only the correct receiver to decode the data

Question 15

Operating system functions: Which of the following are characteristic responsibilities of an operating system?

Accepted Answer

Introduction / Context: An operating system (OS) is the core software layer that manages hardware and provides essential services for applications. Understanding OS responsibilities helps clarify why applications can run efficiently and safely on diverse hardware platforms. Given Data / Assumptions: OS manages CPU, memory, storage, and I/O devices. OS must handle faults and recover from errors when possible. Memory management is a central subsystem (allocation, protection, paging). Concept / Approach: Resource management covers scheduling CPU time, managing filesystems and devices, and sharing resources between processes. Error recovery includes handling exceptions, recovering from device faults, and providing reliability features. Memory management handles allocation, protection, virtual memory, and addressing. All listed items are textbook OS responsibilities. Step-by-Step Solution: Map each option to OS subsystems: resource management (scheduler, I/O, filesystem).Error recovery (exception handling, restart, logging).Memory management (heap/stack allocation, paging, segmentation).Since all apply, choose “All the above”. Verification / Alternative check: Any standard OS syllabus includes these domains as primary OS services, confirming the comprehensive choice is correct. Why Other Options Are Wrong: resource management, error recovery, memory management (alone): Each is correct but incomplete. None of the above: False; these are indeed core OS duties. Common Pitfalls: Overlooking error handling as a formal OS responsibility; conflating resource management with mere hardware drivers; ignoring memory protection as part of management. Final Answer: All the above

Question 16

Semaphore initialization for mutual exclusion: What initial value should a semaphore have so that only one of many processes can enter its critical section at a time?

Accepted Answer

Introduction / Context: Mutual exclusion ensures that concurrent processes do not simultaneously execute a critical section that accesses shared data. A binary semaphore is commonly used to enforce this policy. The correct initial value allows the first entrant and blocks the rest until release. Given Data / Assumptions: Semaphore supports atomic wait (P) and signal (V) operations. We want exactly one process at a time in the critical section. No process should start blocked unnecessarily once the system begins. Concept / Approach: A binary semaphore initialized to 1 indicates the resource is free. The first P makes it 0, entering the critical section. Any subsequent P calls block (since value is 0) until the current process performs V, restoring the semaphore to 1 and allowing the next process to proceed. Step-by-Step Solution: Choose a binary semaphore for exclusivity.Initialize to 1 to allow one immediate entrant.Upon exit, signal (V) to wake the next waiter.This enforces one-at-a-time access to the critical section. Verification / Alternative check: Textbook mutex examples and POSIX semaphores mirror this pattern: initial value 1 for a lock-like behavior. Initial value 0 is used for ordering/barrier patterns, not initial entry. Why Other Options Are Wrong: 8 or 16: Counting semaphore allowing many concurrent entrants, violating mutual exclusion. 0: Blocks all processes at start until a V occurs from outside the section. None of the above: Incorrect because 1 is the standard initial value. Common Pitfalls: Forgetting to release (signal) causing starvation; mixing multiple locks inconsistently causing deadlock; using a counting semaphore inadvertently when exclusivity is required. Final Answer: 1

Question 17

Dynamic storage allocation: In which placement strategy is a program loaded into the largest available free hole (block) in main memory?

Accepted Answer

Introduction / Context: Dynamic storage allocation policies decide where to place a new process or segment in main memory. Different strategies trade off external fragmentation, search time, and future flexibility. Recognizing each strategy by its rule is vital for OS memory management questions. Given Data / Assumptions: Memory consists of variable-sized free holes. A request arrives for a block of a certain size. The strategy determines which hole is chosen. Concept / Approach: First fit picks the first hole large enough. Best fit chooses the smallest hole that is big enough, trying to minimize leftover waste. Worst fit chooses the largest hole available, aiming to leave sizeable remainders that might accommodate future requests better (though this can increase fragmentation in practice). Buddy systems split memory in powers of two and are not a simple “largest-hole” choice. Step-by-Step Solution: Identify the rule described: place into the largest free block.Map to known strategies: “largest hole” corresponds to worst fit.Confirm that best fit is “smallest adequate hole” and first fit is “first adequate hole”.Therefore, select worst fit. Verification / Alternative check: Standard OS references define worst fit exactly as using the largest available hole, distinguishing it from first and best fit. Why Other Options Are Wrong: best fit: Chooses the smallest adequate hole, not the largest. first fit: Chooses the first adequate hole in address order. buddy: Splits from powers-of-two blocks, not a hole-choice rule like “largest”. None of the above: Incorrect because worst fit matches. Common Pitfalls: Confusing best fit with worst fit; assuming worst fit always reduces fragmentation (results vary by workload); overlooking search overhead differences among strategies. Final Answer: worst fit

Question 18

Virtual memory basics: What is the role of a page-map table (page table) in a paged virtual memory system?

Accepted Answer

Introduction / Context: Paged virtual memory lets processes use contiguous logical addresses even when their physical pages are scattered in RAM. The hardware and OS cooperate using a page table to translate virtual addresses to physical addresses at runtime. Given Data / Assumptions: Virtual addresses are divided into page number and offset. Physical memory is divided into frames of the same size as pages. A data structure maps page numbers to frame numbers plus status bits. Concept / Approach: The page-map table (page table) holds entries that pair each virtual page number with a physical frame number and flags (valid, dirty, referenced, protection). The memory management unit (MMU) consults the page table (often via a TLB cache) to translate virtual addresses on the fly. It is neither a mere “data file” nor a “directory” in the filesystem sense. Step-by-Step Solution: Identify components of a virtual address: VPN (virtual page number) and offset.Use the page table to map VPN -> PFN (physical frame number) if valid.Construct the physical address as PFN concatenated with the offset.Therefore, the page table is for address translation. Verification / Alternative check: Hardware manuals and OS texts specify MMU translation via page tables and TLBs; exceptions occur on invalid entries, triggering page faults. Why Other Options Are Wrong: A data file / A directory: These are storage abstractions, not memory-translation structures. All of the above: False because only address translation is accurate. None of the above: Incorrect because address translation is correct. Common Pitfalls: Confusing page tables with filesystem directories; overlooking protection bits and their role (e.g., read/write/execute) during translation. Final Answer: Used for address translation

Question 19

Scheduling policy behavior: Which scheduling approach permits temporarily suspending a currently runnable process so another process can run (i.e., supports preemption)?

Accepted Answer

Introduction / Context: Schedulers arbitrate CPU time among runnable tasks. A key distinction is whether a running task can be involuntarily paused to allow another task to run. This is essential for responsiveness in interactive systems and for meeting deadlines in real-time systems. Given Data / Assumptions: Multiple runnable tasks compete for a single CPU. We seek a policy that allows interruption of the current task. Alternative policies may require the running task to yield or finish its CPU burst. Concept / Approach: Preemptive scheduling allows the OS to interrupt and context-switch from the running task, e.g., at timer interrupts or priority changes. Non-preemptive scheduling (cooperative) waits for the running task to relinquish the CPU. FIFO/FCFS are typically non-preemptive queue disciplines that do not forcibly suspend a running task. Step-by-Step Solution: Identify requirement: temporarily suspend runnable process.Map to scheduling types: this is preemption.Recognize that FIFO/FCFS are order policies, usually non-preemptive without time slicing.Thus, preemptive scheduling is correct. Verification / Alternative check: Classic algorithms like Round Robin and Priority Preemptive are explicitly preemptive, supporting timer-based context switches for fairness and responsiveness. Why Other Options Are Wrong: non-preemptive scheduling: Does not allow involuntary suspension. FIFO / FCFS: Typically non-preemptive; once running, a job continues until completion or blocking. None of the above: Incorrect because preemptive scheduling fits exactly. Common Pitfalls: Assuming FCFS implies preemption; confusing time slicing (preemption) with cooperative yields; ignoring interrupt-driven timer ticks enabling preemption. Final Answer: preemptive scheduling

Question 20

Definition of paging: Which statement correctly defines paging in operating systems, focusing on how programs and memory are subdivided?

Accepted Answer

Introduction / Context: Paging is a fundamental virtual memory technique that simplifies allocation and avoids external fragmentation by using fixed-size units. Understanding its definition distinguishes it from address spaces, CPU scheduling, and generic multiprogramming concepts. Given Data / Assumptions: Programs (logical memory) are divided into pages of equal size. Physical memory is divided into frames of the same size. Hardware/OS translate addresses page-by-page. Concept / Approach: Paging breaks the program into pages and maps them to physical frames, enabling noncontiguous allocation. Option A captures this exactly. Option B describes the address space. Option C refers to CPU time allocation (scheduling), not memory. Option D describes the outcome of multiprogramming, not the specific mechanism of paging. Step-by-Step Solution: Match the definition: “equal portions of program and core” describes paging and frames.Eliminate distractors: address space, CPU time allocation, generic co-residency.Select the statement that explicitly mentions equal portions (pages/blocks). Verification / Alternative check: OS literature defines paging precisely this way and contrasts it with segmentation (variable-sized units) and contiguous allocation (prone to external fragmentation). Why Other Options Are Wrong: consists of addresses that may be generated: That is the virtual address space. allocating processor time: CPU scheduling, not memory management. allows multiple programs to reside: True of multiprogramming, not paging’s definition. None of the above: Incorrect because A is correct. Common Pitfalls: Confusing paging with segmentation; believing frames can differ in size from pages; assuming paging eliminates all fragmentation (it eliminates external, not internal fragmentation). Final Answer: is a method of memory allocation by which the program is subdivided into equal portions, or pages and core is subdivided into equal portions or blocks.

Operating Systems Concepts Questions