Educational Platform

Master Operating
Systems — Visually

From file management to CPU scheduling — learn, simulate, and test your OS knowledge with interactive tools built for students.

🚀 Start Learning ⚙️ Open Simulator 📝 Take a Test
3
Core Topics
30+
Practice Qs
6
Algorithms
Free
Always
Why Mini OS

Everything you need to ace OS

A structured path from beginner to confident — no textbooks required.

📖

Structured Notes

Detailed, concise explanations of File Management, Memory Management & Process Scheduling.

⚙️

Live Simulator

Add processes, pick an algorithm, and watch the Gantt chart and metrics generate in real time.

Instant Feedback

Practice questions reveal explanations the moment you answer — no waiting, no guessing.

🎯

Smart Tests

Randomized MCQ tests with scoring, a progress bar, and personalized performance remarks.

Learning Modules

Three pillars of OS

Pick a topic to dive in. Each module has key concepts, examples, and diagrams.

File management is a core OS function — it controls how data is stored, retrieved, organized, and protected on storage devices.

🔑 Key Functions

  • Creation & Deletion — OS allows creating/removing files and directories.
  • Access Control — Sequential, direct (random), or indexed access methods.
  • Naming — Assigns names + extensions (e.g., report.docx) for identification.
  • Organization — Groups files into directories/folders.
  • Security — Permissions: read, write, execute.
  • Backup & Recovery — Guards against accidental loss or corruption.

📋 File Attributes

Name
e.g., notes.txt
Type
text / binary / image
Location
path on disk
Size
number of bytes
Protection
rwx permissions
Timestamps
created / modified

📑 File Access Methods

MethodDescriptionExample
SequentialRecords read one after another in order.Text file read line by line
Direct (Random)Access any position without reading through prior data.Database records
IndexedUses an index structure to locate data blocks rapidly.Index at back of textbook

📚 Directory Structures

  • Single-Level — All files in one flat directory. Simple, but cluttered.
  • Two-Level — Each user has their own separate directory.
  • Tree-Structured — Hierarchical folders & sub-folders (most common today).
  • Acyclic Graph — Files can be shared across multiple directories without loops.
  • General Graph — Most flexible; allows cycles but needs garbage collection.

🔒 Protection Mechanisms

ACLs
Per-user permission lists
Passwords
Simple but weaker
Encryption
Encodes file data
💡 Real-world example: When you save hello.c — the OS creates the file, records attributes (size, date, type), and enforces permissions so only authorized users can edit or delete it.

Memory Management ensures programs run smoothly by allocating, tracking, and freeing RAM efficiently — preventing conflicts when multiple processes share limited memory.

🎯 Main Goals

  • Efficient Allocation — Divide RAM between processes without waste.
  • Protection — Stop one process reading another's memory space.
  • Relocation — Move processes in memory for better utilization.
  • Sharing — Allow safe shared access between cooperating processes.
  • Address Translation — Map logical (program) addresses → physical (hardware) addresses.

📦 Allocation Strategies

StrategyHow it worksExample (90 KB needed)Trade-off
First FitUse the first block that's large enough.Picks 100 KB blockFast, but wastes leftover space
Best FitUse the smallest block that fits.Picks 100 KB blockLess waste, slower search
Worst FitUse the largest available block.Picks 500 KB blockLeaves large holes, useful for future

📊 Paging vs Segmentation

Paging
Fixed-size pages/frames. Eliminates external fragmentation. Used in virtual memory systems.
Segmentation
Variable-size segments (code, data, stack) matching program structure. Good for sharing & protection.

🧩 Fragmentation

  • Internal Fragmentation — Allocated block slightly larger than needed; waste inside a block.
  • External Fragmentation — Enough total free memory exists, but it's scattered in small unusable holes.
💡 Analogy: Think of RAM like a hotel. Paging assigns fixed-size rooms; segmentation assigns rooms by the group's actual size. Internal fragmentation = half-empty room. External fragmentation = no single room big enough despite having enough total empty beds.

Process Scheduling determines the order processes execute on the CPU — maximizing utilization while providing fair response times for all users.

⚙️ Preemptive vs Non-Preemptive

Preemptive
Running process can be interrupted and returned to ready queue. E.g., Round Robin, SRTF.
Non-Preemptive
Process runs to completion (or blocking). E.g., FCFS, Non-Preemptive SJF/Priority.

⚡ Scheduling Algorithms

AlgorithmHow it worksProCon
FCFSProcesses execute in arrival order (FIFO).SimpleConvoy effect (long jobs block short ones)
SJFShortest burst runs first.Minimizes avg. waitStarvation of long jobs
PriorityHighest-priority process runs first.Critical tasks fastStarvation (fix with aging)
Round RobinEach process gets a fixed time quantum, then rotates.Fair for time-sharingHigh quantum → FCFS; low → high context-switch overhead
SRTFPreemptive SJF — shortest remaining time runs.Optimal avg. waitHigh preemption overhead

⏱️ Key Metrics

Waiting Time
Time process spends in ready queue
Turnaround Time
Completion − Arrival time
Response Time
First run − Arrival time
Throughput
Processes completed / unit time
CPU Utilization
% of time CPU is busy
💡 Quick example (FCFS): P1(AT=0,BT=5), P2(AT=1,BT=3), P3(AT=2,BT=2) → Order: P1→P2→P3. Avg. waiting time = (0 + 4 + 6) / 3 = 3.33 units.

Process Scheduling Simulator

Add processes, choose an algorithm, and visualize execution on a Gantt chart with computed metrics.

Add Process

No processes yet

Algorithm

Gantt Chart
Run simulation to see Gantt chart

Results Table

PIDATBTWTTATRTCT
Practice Questions

Test your understanding

Five randomized questions from all three topics. Click an option to see if you got it right — with an explanation.

Loading questions…
Assessment

Mini OS Quiz

Answer MCQs from all three topics. Submit to see your score and remarks.


Quick Reference

OS Glossary

Key terms at a glance.

Process
A program in execution, with its own address space and state.
CPU Burst
The amount of time a process needs on the CPU before its next I/O operation.
Context Switch
Saving/restoring CPU state when switching between processes.
Starvation
A process never gets CPU time because higher-priority jobs keep arriving.
Aging
Gradually increasing a waiting process's priority to prevent starvation.
Deadlock
Two or more processes block forever, each waiting for a resource held by the other.
Paging
Dividing memory into fixed-size pages to eliminate external fragmentation.
Segmentation
Dividing memory into variable-size segments matching logical program structure.
Virtual Memory
Technique allowing execution of processes not entirely in RAM, using disk as overflow.
Thrashing
Excessive paging causing the system to spend more time swapping than executing.
Semaphore
A synchronization primitive used to control access to shared resources.
Race Condition
Outcome depends on non-deterministic ordering of concurrent operations.
Team

About Mini OS

Built by a passionate team to make OS concepts accessible and engaging for every student.

M
Madhav Davda
Project Manager & Frontend Developer
D
Dhara Nagar
Content Designer
I
Isha Gopani
Tester & Documentation Lead
K
Kunj Shah
Frontend Developer
N
Nisarg Rasania
Backend & Logic Developer
Community

Student Reviews

Share your thoughts. Reviews are saved in your browser.

Leave a Review