UGC NET Computer Science & Applications Topic-wise Practice

🖥️

System Software and Operating System

System Software and Operating System is Unit 5 of the UGC NET Computer Science and Applications syllabus, and it is the most arithmetic-heavy unit in the paper. Average waiting time, head movement in cylinders, effective memory access time, page-fault counts, disk capacity — these are calculated, not remembered, and one slip in the schedule you sketch costs the whole mark. It is also the unit most likely to give you a single table or passage and then ask five separate questions from it, so the setup you do once pays five times.

15 sets10 Q per set

Recommended next

View all sets PYQs & full tests

Available Practice Sets

Choose any set, or follow the recommended next set above.

Recommended

Every System Software and Operating System question ever asked

156 previous year questions from 2018–2026, each with its options and the correct answer — free to read.

View 156 PYQs

What this topic covers

1System software: assemblers, loaders, linkers and macro processors, and which stage resolves which kind of reference

2Process management: the process state diagram, the scheduling algorithms, and what a context switch actually saves

3Threads, inter-process communication, and the synchronisation primitives that coordinate them

4The classical synchronisation problems, semaphores and monitors, and why busy waiting is what they exist to avoid

5Deadlock: prevention, avoidance through Banker's algorithm, detection with a wait-for graph, and recovery

6Memory management: contiguous allocation, paging, segmentation, and the kind of fragmentation each one produces

7Virtual memory, the page replacement algorithms, and thrashing

8File systems, directory structures, allocation methods, and the disk scheduling algorithms

9Unix and Linux fundamentals, process creation with fork, and shell programming

Key concepts to revise

1The number of frames is physical memory divided by page size. Virtual memory size never enters the calculation, and it is offered as a distractor precisely because candidates reach for it

2SCAN and C-SCAN travel to the physical end of the disk before reversing or wrapping; LOOK and C-LOOK turn at the last pending request. The head-movement totals differ, and so does the answer

3LRU is not universally better than FIFO. On a given reference string LRU can take more faults than FIFO, so the counts have to be simulated rather than assumed

4Effective memory access time with a TLB: a hit costs the TLB search plus one memory access, a miss costs the search plus two, because the page table is read and then the data

5Banker's algorithm grants a request only when the resources are available, the request stays within the process's declared maximum, and the resulting state is safe — nothing about being the only requester

6Banker's holds Available as a vector and Maximum, Allocation and Need as matrices. A wait-for graph belongs to deadlock detection, which is a different strategy from avoidance

7The process control block stores the process state, its scheduling information, the saved CPU registers and its memory-management tables — but not the program's own code and data segments

8Round Robin's time quantum is the standard remedy for the starvation that shortest-job-first can cause

9Highest Response Ratio Next selects the largest value of waiting time plus service time, divided by service time

10Privileged instructions run only in kernel mode. No permission setting lets a user-mode application execute one directly; it has to trap into the kernel

How to prepare this topic

1Sketch the schedule for every CPU-scheduling question before touching the options. FCFS, shortest-job-first, priority and Highest Response Ratio Next all rest on the same diagram — what changes is which average is wanted, and keeping turnaround, waiting and response distinct is what actually separates the four

2Learn the disk questions as a pair of skills: totalling head movement in cylinders for a given algorithm, and reading disk geometry, where a cylinder is one track on every surface and capacity multiplies surfaces by tracks by sectors by bytes. A recent paper gave one disk table and asked five questions from it

3Treat Banker's algorithm as a block rather than a fact. The papers have used a single passage to ask its goal, its data structures, the conditions for granting a request, and what its safety guarantee actually buys

4Memorise the short arithmetic that keeps recurring — frames equal memory divided by page size, maximum rotational delay is sixty divided by rpm, and an i-node reaches direct plus entries plus entries-squared blocks where entries is block size divided by address size

5For fork questions, count processes as two to the power of the number of calls, then place each print relative to the forks preceding it. The trap is always a print sitting between two forks rather than after all of them

Common mistakes to avoid

1Using virtual memory size to work out the frame count, when only physical memory and page size matter

2Sending the head all the way to cylinder zero or the last cylinder on a LOOK or C-LOOK question, when those algorithms turn at the last pending request

3Assuming LRU always beats FIFO, when which one faults more depends entirely on the reference string in front of you

4Charging a single memory access on a TLB miss, when the page table is read first and the data afterwards

5Listing the program's code and data segments among the contents of the process control block

6Confusing deadlock avoidance with detection — Banker's keeps the system in a safe state before granting, while a wait-for graph finds a cycle after the fact

7Averaging the wrong quantity: turnaround is completion minus arrival, waiting is turnaround minus burst, and response is first start minus arrival

8Re-deriving the table from scratch for each question in a common-data set, when one careful setup answers every question in the group

Frequently Asked Questions

How many questions come from System Software and Operating System in UGC NET Computer Science Paper 2?

There is no published quota for any unit. What is distinctive here is that the count is lumpy rather than steady — because the examiners like to attach several questions to one shared table or passage, a single disk specification or a Banker's algorithm scenario can be worth five marks on its own. That makes the unit high-variance and worth preparing properly.

How much of this unit is calculation rather than theory?

Most of it. Scheduling averages, disk head movement and geometry, page-fault counts, effective access time and page-table sizing are all worked numerically. The theory pockets are smaller and quite predictable: the contents of a process control block, what privileged instructions may do, what mutual exclusion guarantees, and the trade-offs between file allocation methods.

If I only have a week for this unit, what should I practise first?

Disk scheduling and disk geometry first, then CPU scheduling averages, then Banker's algorithm and paging arithmetic. Between them these four account for the large majority of questions from this unit in recent papers, and all four are calculated rather than recalled.

Do I need to know Linux commands and shell scripting?

At a basic level, yes. The syllabus lists Unix and Linux fundamentals, and papers have asked about kernel interrupt levels and about what a sequence of fork calls prints. You are not asked to write a shell script, but you are expected to read a short C program using fork and work out how many processes it creates.

Should I learn all the page replacement algorithms or just FIFO and LRU?

FIFO, LRU and optimal are the three worth knowing properly, because the questions compare their fault counts on one supplied reference string. Since the comparison is the question, recognising the algorithm names is not enough — you need to be able to simulate each of them quickly on paper.