Systems Software — OCR A-Level Computer Science
Systems Software explained
Systems Software covers 8 specification points, including (a) The need for, function and purpose of… and (b) Memory Management (paging, segmentation….
Read the full explanation
Open a point below for its explanation and revision guidance.
(a) The need for, function and purpose of operating systems.
An operating system (OS) is systems software that sits between hardware and application software. It is needed because raw hardware is hard to use: without an OS, each program would have to control devices, share the processor and memory safely and handle errors itself. The OS's functions include managing processes, memory, files, devices and the user interface. Its purpose is to make the computer usable, efficient and secure by managing resources for users and applications. For example, when a student saves a document, the application asks the OS to write it, and the OS chooses where the data is stored and records it in a directory. Learners should state the need, describe each function and link it to the purpose.
(b) Memory Management (paging, segmentation and virtual memory).
Memory management allocates main memory to processes, tracks its use and protects each process's memory. Paging divides logical memory into fixed-size pages and physical memory into equal frames; a page table maps pages to frames, so contiguous memory is unnecessary. Segmentation divides a program into variable-length segments, such as code and data, tracked by base and limit values; gaps can cause external fragmentation. Virtual memory keeps only some pages in RAM and the rest on secondary storage, so a process may exceed installed RAM. A page fault occurs when a needed page is absent, prompting the OS to load it. Example: 4 KiB (2¹² bytes) pages in a 32-bit address space use a 12-bit offset and a 20-bit page number.
(c) Interrupts, the role of interrupts and Interrupt Service Routines (ISR), role within the Fetch-Decode-Execute Cycle.
An interrupt is a signal, from hardware such as a keyboard or timer, or from software, that asks the processor to pause its current task and deal with an event. Interrupts let the CPU respond to events without constantly checking devices. Within the Fetch-Decode-Execute cycle, the processor checks for a pending interrupt after the execute stage completes, so the current instruction finishes before control changes. If an interrupt is present, the program counter and status information are saved, usually to the stack, and the address of the matching Interrupt Service Routine (ISR) is loaded into the program counter. An ISR is the short program that handles that specific event, for example reading a key code from a keyboard buffer. When the ISR ends, the saved values are restored and the cycle fetches the next instruction from the point where the original program stopped.
(d) Scheduling: round robin, first come first served, multi-level feedback queues, shortest job first and shortest remaining time.
Scheduling decides which ready process the processor runs next, and each named algorithm chooses differently. Round robin gives every process a fixed time slice in turn, returning unfinished processes to the back of the queue. First come first served runs processes in arrival order without interruption, so a long job can delay short ones. Shortest job first picks the ready process with the smallest expected run time, while shortest remaining time is its preemptive form, switching when a new process has less remaining time than the running one. Multi-level feedback queues use several queues with different priorities and time slices, moving processes between them according to their behaviour. For processes of 8 ms, 4 ms and 2 ms arriving together in that order, first come first served gives an average waiting time of 6.67 ms, while shortest job first gives 2.67 ms.
(e) Distributed, embedded, multi-tasking, multi-user and Real Time operating systems.
This statement asks you to identify five operating system types and state what each is designed to do. A distributed OS manages several networked computers so they appear to users as one system, sharing files and processing. An embedded OS runs a dedicated device, such as a washing machine controller, with a fixed function and limited memory. A multi-tasking OS switches the processor between tasks through time slicing, so several programs appear to run at once. A multi-user OS lets several people log in at once, each with separate accounts and permissions. A real time OS guarantees responses within deadlines, as in airbag or industrial robot control. Learn each type by its defining feature.
(f) BIOS.
This statement asks you to recognise BIOS, the Basic Input/Output System, and describe its role when a computer starts. BIOS is firmware stored in read-only or flash memory on the motherboard, so it is available as soon as power is applied. When the computer starts, it runs a power-on self-test to check key hardware, initialises devices such as the keyboard, display and storage, and then locates a boot device. It hands control to the bootloader stored on that device, which loads the operating system. Because BIOS supplies low-level input and output routines, it sits between hardware and the OS during start-up. Modern PCs often use UEFI firmware for the same job, but this specification names BIOS.
(g) Device drivers.
Device drivers are pieces of software that allow the operating system to communicate with and control hardware devices such as printers, keyboards, graphics cards and storage. Each device has its own control interface, so a driver translates the generic instructions the operating system issues into the specific commands that a particular device understands. For example, when an application asks the operating system to print a page, the operating system passes the request to the printer driver, which converts it into the printer's own commands and sends them through the relevant connection. Drivers are usually written by hardware manufacturers and installed on the system, so the operating system can use a device without needing to know its internal workings.
(h) Virtual machines, any instance where software is used to take on the function of a machine, including executing intermediate code or running an operating system within another.
A virtual machine is software that takes on the function of a machine. The statement covers any instance of this, not only one product, and names two examples. First, executing intermediate code, such as Java bytecode run by the Java Virtual Machine. Second, running an operating system within another: a guest operating system runs inside a host operating system, which supplies the hardware it sees through software. Learners should state the general idea, then describe each example, explaining that software performs work the hardware would normally do. For instance, Linux running inside Windows through virtualisation software is a virtual machine.
Your focus
- Identify the need for an operating system when hardware is used by several programs.
- Explain how at least one OS function contributes to the overall purpose of the OS.
- Give an example of an OS function being used during everyday computer use.
Show all 24 objectives
- Describe how paging maps pages to frames using a page table.
- Compare paging and segmentation in terms of block size and fragmentation.
- Explain the role of a page fault in virtual memory.
- Identify the point in the Fetch-Decode-Execute cycle at which a pending interrupt is checked.
- Describe the steps the processor takes when an interrupt is accepted, including saving and restoring state.
- Explain the purpose of an Interrupt Service Routine in handling a specific event.
- Identify each named scheduling algorithm from a description of its selection rule.
- Calculate average waiting time for first come first served and shortest job first given burst times.
- Explain why shortest remaining time is preemptive while basic shortest job first is non-preemptive.
- Identify each of the five operating system types named in the specification.
- Describe the defining feature of each operating system type.
- Match a given scenario to the correct operating system type.
- Identify BIOS as the Basic Input/Output System.
- State where BIOS is stored and when it runs.
- Describe the role of BIOS in initialising hardware and starting the boot process.
- State the role of a device driver within systems software.
- Identify the translation a driver performs between generic operating system instructions and device-specific commands.
- Distinguish device drivers from applications and from hardware components in multiple-choice questions.
- Define a virtual machine as software that takes on the function of a machine.
- Give the two named examples, executing intermediate code and running an operating system within another, with a correct description of each.
- Distinguish a virtual machine from machine code executed directly by the processor in multiple-choice questions.
Systems Software exam tips
Marking Points
- States that an operating system manages hardware resources on behalf of users and applications.
- Explains the need for an OS by describing how difficult raw hardware is to use without shared control.
- Describes at least one function, such as process, memory, file or device management, or the user interface.
- Links each function to the overall purpose of making the computer usable, efficient and secure.
- Gives a concrete example, such as the OS deciding where a saved file is stored and recording it in a directory.
- States that memory management allocates main memory to processes and protects each process's memory.
- Describes paging as fixed-size pages mapped to frames through a page table, so memory need not be contiguous.
- Describes segmentation as variable-length segments that match a program's structure, tracked with base and limit values.
- Explains that virtual memory uses secondary storage for pages not held in RAM, with a page fault prompting the OS to load a page.
- Identifies the fragmentation trade-off: internal fragmentation with paging and external fragmentation with segmentation.
- Defines an interrupt as a signal that causes the processor to suspend its current task.
- Identifies the role of interrupts as allowing the CPU to respond to events without continuous polling.
- Places the interrupt check at the end of the execute stage, not in the middle of an instruction.
- Describes saving the program counter and status before the ISR runs, and restoring them afterwards.
- Explains that an ISR is a routine that handles one specific interrupt and returns control to the interrupted program.
- Defines round robin as allocating a fixed time slice to each process in turn.
- Describes first come first served as running processes in arrival order without preemption.
- Explains that shortest job first selects the ready process with the smallest expected run time.
- Distinguishes shortest remaining time as the preemptive form that can switch to a newly arrived shorter process.
- Describes multi-level feedback queues as using several queues with different priorities that move processes between them.
- Names all five types: distributed, embedded, multi-tasking, multi-user and real time.
- Describes a distributed OS as coordinating networked computers so they appear to users as one system.
- Describes an embedded OS as dedicated to a specific device with a fixed function and limited resources.
- Explains multi-tasking as sharing processor time between several tasks, and multi-user as letting several people use the system at the same time.
- Explains a real time OS as guaranteeing that responses occur within a specified deadline.
- Identifies BIOS as the Basic Input/Output System.
- Describes BIOS as firmware held in ROM or flash memory on the motherboard.
- Explains that BIOS runs at power-on, tests and initialises hardware before the operating system loads.
- Links BIOS to locating a boot device and passing control to the bootloader.
- Identifies a device driver as systems software that enables communication between the operating system and a hardware device.
- Explains that a driver translates generic operating system instructions into commands specific to one device.
- Recognises that each driver is written for a particular device or type of device, so a different device needs a different driver.
- Gives an accurate example, such as a printer driver or graphics card driver, and links it to the device's function.
- Distinguishes a driver from user applications and from the physical hardware it controls.
- Identifies a virtual machine as software that performs the function of a machine rather than physical hardware.
- Recognises that the definition covers any instance of software taking on machine functions, not only full system emulation.
- Identifies the execution of intermediate code, such as Java bytecode run by the Java Virtual Machine, as an example.
- Identifies running an operating system within another, with a guest operating system inside a host operating system, as an example.
- Explains a practical reason for using a virtual machine, such as running software designed for a different platform.
Examiner Tips
- 💡Learn the need, functions and purpose as linked ideas so that a question on one part can be answered using the others.
- 💡For MCQ options, eliminate any option that presents the OS as an application program.
- 💡When an option lists several functions, check that each one is genuinely an OS responsibility rather than a task for application software.
- 💡Draw a labelled diagram showing a page table mapping page numbers to frame numbers, so the translation process is clear.
- 💡In MCQs, check whether an option describes fixed or variable block sizes, as this identifies whether it refers to paging or segmentation.
- 💡Work through the 4 KiB, 32-bit example to see how the address bits split into offset and page number.
- 💡Name the stage after which the interrupt is checked, and state briefly why the current instruction is not interrupted part-way.
- 💡Write the sequence of steps when an interrupt is accepted, in order: save state, load ISR address, run ISR, restore state.
- 💡Give one concrete example of a hardware interrupt and one of a software interrupt to show you understand both sources.
- 💡For each algorithm, state its selection rule and whether it is preemptive, since these two points are often tested together.
- 💡When calculating average waiting time, write the process order first, then the waiting time of each process, then the average.
- 💡Learn the defining rule of each algorithm in one sentence so you can match a description to the correct name quickly.
- 💡Learn each operating system type with its defining feature and one realistic example.
- 💡When options look similar, eliminate any choice that describes a different type's defining feature.
- 💡Read the scenario for keywords such as users, deadlines, devices or networked computers, and match them to the correct type.
- 💡Memorise the expansion Basic Input/Output System and link it to start-up.
- 💡Describe where BIOS is stored and when it runs, since these are common distinguishing features in questions.
- 💡If an option mentions UEFI, check whether the question specifically asks about BIOS before choosing it.
- 💡Check each MCQ option for whether it describes software that connects the operating system to hardware, and reject options that describe user programs or physical parts.
- 💡Eliminate options that say a driver is used by the user directly, since drivers serve the operating system.
- 💡When a stem asks about the purpose of a driver, link your answer to a concrete device, such as a printer, to show you understand the translation role.
- 💡Check whether each option covers both the general definition and the specific examples named in the statement.
- 💡Reject options that restrict virtual machines to hardware or to operating systems alone.
- 💡Use the terms host and guest accurately when describing an operating system running inside another operating system.
Common Mistakes
- Describes the OS as application software; correct this by stating that it is systems software sitting between hardware and applications.
- Lists functions without explaining why they are needed; correct this by linking each function to resource management or usability.
- Treats the OS as only a user interface; correct this by including process, memory, file and device management as well.
- Describes pages and segments as the same size; correct this by stating that pages are fixed in size while segments vary in length.
- Says virtual memory increases the amount of physical RAM; correct this by stating that it uses secondary storage to give the appearance of more memory.
- Confuses internal and external fragmentation; correct this by stating that internal fragmentation is unused space inside a page and external fragmentation is gaps between segments in memory.
- Describes interrupts as a method the CPU uses to check devices in a loop, which confuses them with polling; correct this by stating that the device signals the processor.
- Places the interrupt check in the middle of the fetch stage, which is incorrect; correct this by placing it after the execute stage completes.
- States that the ISR replaces the interrupted program permanently, which is wrong; correct this by explaining that the saved state is restored when the ISR ends.
- Treats the ISR as the hardware that generates the signal, which mixes up the source of the interrupt with the routine that handles it; correct this by separating the signal from the program.
- Describes shortest remaining time as non-preemptive, which is incorrect; correct this by stating that it can preempt a running process when a shorter one arrives.
- Describes round robin as running each process to completion, which is wrong; correct this by stating that each process runs for one fixed time slice before rotating.
- Describes multi-level feedback queues as using a single queue with one fixed priority, which misses the movement between queues; correct this by stating that processes move between queues.
- Calculates first come first served waiting times using the shortest burst first, which applies the wrong order; correct this by listing processes in arrival order.
- Mixes up multi-tasking and multi-user, treating both as the same idea; correct this by remembering that multi-tasking concerns tasks while multi-user concerns people.
- Treats real time as simply fast processing; correct this by stating that the defining feature is meeting a deadline reliably.
- Describes an embedded OS as a general-purpose desktop system; correct this by stating that it is dedicated to one device with a specific function.
- Treats BIOS as the operating system; correct this by describing it as firmware that prepares hardware before the OS loads.
- Describes BIOS as application software stored on the hard disk; correct this by stating that it is held in ROM or flash memory on the motherboard.
- Assumes BIOS only runs when a user opens a program; correct this by stating that it runs automatically at power-on.
- Describes a device driver as an application the user opens to perform a task; correct this by stating that drivers run in support of the operating system and are not user programs.
- Treats a device driver as a physical component built into the device; correct this by stating that a driver is software installed on the computer.
- Claims that one driver works with any device; correct this by stating that drivers are specific to the device or device type they control.
- Treats a virtual machine as only a complete operating system running inside another; correct this by including the execution of intermediate code as a second valid instance.
- Describes a virtual machine as a physical computer built into the host; correct this by stating that the machine's function is provided by software.
- Confuses intermediate code with machine code that runs directly on the processor; correct this by stating that intermediate code is executed by a virtual machine rather than directly by the hardware.