Start with the course you actually have
Operating systems courses share core ideas, but the depth and emphasis vary. One course may spend more time on concurrent programming; another may ask you to calculate page faults or compare file-system designs. Begin with your course outline, lecture slides, required readings and past assignments. Check your institution’s materials for the topics and assessment formats you are expected to know rather than assuming a standard syllabus.
Turn those materials into a list of examinable sections. A useful starting set is processes and threads, CPU scheduling, synchronisation, deadlocks, memory management, virtual memory, file systems, and input/output. Add or remove topics to match your own course. For each section, note whether you need to explain a concept, trace an algorithm, calculate a result, or analyse a trade-off. That distinction determines how you should practise it.
A board on this topic ends up looking like this:
- A process has its own address space and resources; threads within a process share its address space.
- A context switch saves the running execution state and restores another; switching has overhead.
Paging maps virtual pages to physical frames through page tables. A page fault occurs when a referenced page is not currently resident in memory.
| Algorithm | Selection rule | Typical trade-off |
|---|---|---|
| FCFS | Arrival order | Simple; convoy effect can occur |
| SJF | Shortest next CPU burst | Low average waiting time if burst lengths are known |
| Round robin | Rotate after a time quantum | Responsive; quantum affects overhead |
- An inode stores file metadata and references to data blocks; a directory maps names to file identifiers.
- A hard link is another directory entry for the same file inode; a symbolic link stores a pathname.
- A race condition occurs when an outcome depends on interleaving access to shared state.
- Deadlock requires mutual exclusion, hold and wait, no pre-emption, and circular wait.
Study each section with the right kind of practice
Processes, threads and system calls
Start by explaining what the operating system is managing: execution, memory, devices, and persistent data. Practise distinguishing a process from a program and a thread from a process. Then trace a short sequence of events: a process makes a blocking system call, the kernel handles it, and the scheduler may run another ready process. Be precise about what changes and what is shared.
A useful self-test is to explain the difference between user mode and kernel mode, and why a system call crosses that boundary. Then draw a process-state diagram using the states and transitions your course teaches. Don’t memorise a diagram without being able to explain what event causes each transition.
Scheduling: calculate, then interpret
Scheduling questions reward orderly working. For each process, write down its arrival time and CPU burst, then make a timeline. Apply the specified algorithm exactly, including the stated tie-breaking rule and time quantum. From the timeline, calculate the requested measures. Common definitions are:
- Turnaround time = completion time − arrival time.
- Waiting time = turnaround time − CPU burst time, when the process has one CPU burst and no other waiting categories are being counted.
- Response time = first time scheduled − arrival time.
Check the question’s definitions: a course may distinguish ready-queue waiting from time blocked for I/O. After calculating, explain what the result says about the workload. For instance, round robin can improve responsiveness for interactive jobs, but a very small quantum causes more context switches. Don’t claim one algorithm is universally best.
Synchronisation: trace the shared state
For a mutex, semaphore or monitor problem, list the shared variables and the operations that must be indivisible. Trace a small interleaving of two threads to see whether a race, lost update or deadlock is possible. When asked to fix a race, show where mutual exclusion is acquired and released, and check that every path releases the lock.
For semaphore questions, write the initial value and state what each wait and signal operation does under the convention used in your course. Then test the solution against the required property: mutual exclusion, progress, or bounded waiting. A solution that prevents simultaneous access may still fail if it can deadlock or starve a thread.
Deadlocks: identify the condition and the remedy
Learn the four Coffman conditions and be able to identify each in a scenario: mutual exclusion, hold and wait, no pre-emption, and circular wait. For a resource-allocation graph, label process and resource nodes and follow the edges; whether a cycle proves deadlock depends on the resource-instance assumptions in the problem.
Compare prevention, avoidance, detection and recovery rather than treating them as synonyms. If your course includes the Banker’s algorithm, practise checking whether a proposed request leaves a safe sequence. Show the available resources, need, and allocation clearly; don’t skip the safety check just because the request appears small.
Memory and virtual memory: keep the address translation visible
For paging problems, separate the virtual address into page number and offset using the page size given. Use the page table to find the frame, then combine the frame number with the unchanged offset. If the question includes a translation lookaside buffer, follow the hit and miss assumptions it supplies; do not insert a memory-access formula without stating those assumptions.
For page-replacement questions, record the frames after every reference and mark each fault. Use the exact algorithm named—such as FIFO, LRU or optimal—and state how ties are resolved. Compare policies using the reference string in the question, not a remembered example. In explanations, connect virtual memory to the benefits and costs: a process can use an address space independent of physical placement, while page faults and translation work add overhead.
File systems and I/O: connect structures to operations
Learn the data structures your course uses, then trace what happens during an operation such as opening, reading or creating a file. Distinguish a file name in a directory from the metadata and data associated with the file. For disk-scheduling exercises, first plot the requested tracks and current head position, then apply the named policy and show the order of service. Keep numerical assumptions from the question visible in your working.
A “Must not miss core” checklist can condense the facts and definitions you should be able to retrieve before tackling longer problems:
Build a repeatable weekly routine
Use a short cycle for each topic rather than rereading a whole chapter and hoping it sticks. First, review the relevant lecture or reading and add a concise explanation to your notes. Next, close the source and reconstruct the idea from memory: draw the state diagram, write the algorithm steps, or explain the trade-off aloud. Then solve a problem without looking at a worked solution. Finally, check the solution and record exactly what went wrong: a definition, a calculation step, an assumption, or a missed case.
Space your retrieval practice. Revisit difficult facts and procedures the next day, several days later, and again the following week. If you get a card wrong, review the underlying note and test yourself again later; don’t simply repeat it immediately until it feels familiar. For calculation-heavy areas, alternate topics—for example, do a scheduling problem after a memory-translation problem—so you practise choosing the right method as well as executing it.
A six-card drill on scheduling and memory might look like this:
A process arrives at time 2, first runs at time 7, and completes at time 14. What are its response and turnaround times?
Response time = 7 − 2 = 5. Turnaround time = 14 − 2 = 12.
All 6 cards
That is a MySummaries deck, filled with operating systems material. Yours is written from your own notes. Start free
Work through the first card: answer before you reveal the back, then grade how easily you retrieved it. “Again” means you could not retrieve it; “Hard” means the answer took effort or was incomplete; “Good” means correct with reasonable effort; “Easy” means it came readily. Apply the same process to each remaining card. Notice that the cards test definitions and small applications, not entire lectures. A card should be narrow enough that you can judge whether your answer is correct.
Practise in the format your course uses
Once the individual ideas are becoming reliable, work from your course’s past questions, labs and assignments. If the assessment asks for algorithms, practise writing them clearly and explaining their invariants. If it asks for calculations, show intermediate steps so you can locate errors. If it uses short explanations, answer the exact prompt before adding background. Confirm assessment requirements with your course materials; there is no single international operating-systems exam format.
Keep a mistake log with three columns: what the question tested, what you did, and the correction. “Got scheduling wrong” is too vague. “Used completion time instead of first-run time for response time” points to an actionable repair. Rework missed problems from a blank page after a delay, changing the values where possible while keeping the same method.
Use audio as a second retrieval pass
A short audio explanation is useful after you have studied a section, not as a replacement for solving problems. Listen once for the structure, then pause and predict the next step: which process runs next, which frame a page maps to, or what condition is missing from a deadlock argument. Afterwards, compare your prediction with your notes and revisit any point you could not explain.
A lecture generated from a board on virtual memory might sound like this:
Transcript · tap any word to jump there
Start by separating the virtual address into two pieces: the page number and the offset. The page number selects an entry in the process's page table; the offset identifies a location within that page. If the page table maps the virtual page to a physical frame, the physical address uses that frame number with the same offset.
A translation lookaside buffer can cache recent translations, but use the hit and miss costs stated in your problem. Those assumptions determine the effective access calculation. If the page table entry shows that the page is not resident, the reference causes a page fault. The operating system must bring the page into memory and update the mapping before the instruction can proceed.
When no free frame is available, a replacement policy chooses a victim. Trace the reference string one step at a time: show the frames, record each fault, and follow the specified policy. FIFO uses arrival order; LRU uses recent use; optimal replaces the page whose next use is furthest in the future and is mainly a comparison benchmark, because future references are not known in advance.
How MySummaries helps
MySummaries lets you build a revision board from your own operating-systems PDFs, slides and photographed notes, then make flashcards, practise written questions marked against those materials, or listen to an audio lecture based on a board section. Use it to organise your course’s actual definitions and examples, and keep your practice tied to the syllabus you need to learn. Open MySummaries.