munotes®

Principles of Operating Systems Notes | B.Sc. (Computer Science) Semester 3 | Mumbai University | munotes

Official Notes munotes.in

Principles of Operating Systems

B.SC. (COMPUTER SCIENCE) · SEMESTER 3

Strictly as per the University of Mumbai NEP syllabus in force for B.Sc. (Computer Science)

For B.Sc. (Computer Science) students of the University of Mumbai and all its affiliated colleges

Open the book ↓

munotes.in Second Year

Contents

Module I Fundamentals of Operating Systems, Processes and Threads, Process Synchronization, and CPU Scheduling

  1. What an Operating System Is 1
  2. The Two Jobs: Handing Out the Machine, and Hiding It 5
  3. Interrupts, Traps and the Two Modes 10
  4. The Timer, and Why the Operating System Always Gets the Processor Back 15
  5. The Functions of an Operating System 20
  6. Where Operating Systems Run 24
  7. The Services an Operating System Offers 28
  8. The Command Line and the Desktop 32
  9. What a System Call Is 36
  10. Watching System Calls Happen 40
  11. The Six Families of System Call 44
  12. How an Operating System Is Built 48
  13. Microkernels, Modules and What Linux Actually Is 51
  14. What a Process Is 55
  15. The Five States of a Process 59
  16. The Process Control Block 63
  17. The Queues, the Schedulers and the Context Switch 67
  18. Creating a Process: fork 71
  19. Running a Different Program: exec 75
  20. Waiting, Exiting, the Zombie and the Orphan 79
  21. Inter-process Communication: The Two Models 84
  22. Shared Memory, in Code That Runs 88
  23. Pipes 92
  24. Message Queues 96
  25. Blocking and Non-blocking Communication 100
  26. What a Thread Is 104
  27. Making Threads, and Waiting for Them 108
  28. Multicore Programming, and the Limit on It 112
  29. The Three Multithreading Models 116
  30. Thread Pools, and Handing Work Out 120
  31. Measuring It: Sequential Against Threaded 124
  32. The Shape of Every Concurrent Program 129
  33. A Race Condition, Made to Happen 133
  34. The Critical Section Problem, and the Three Conditions 138
  35. Peterson's Solution 142
  36. Hardware Help: Test and Set, and Compare and Swap 146
  37. The Mutex Lock 150
  38. The Semaphore 154
  39. The Bounded Buffer, Solved 158
  40. The Readers and the Writers 163
  41. The Dining Philosophers 167
  42. Monitors and Condition Variables 172
  43. Why Scheduling Exists: The Burst Cycle 177
  44. The Dispatcher, Preemption, and What a Switch Costs 181
  45. The Five Criteria, and the Arithmetic of Each 185
  46. Reading and Drawing a Gantt Chart 188
  47. First Come First Served 191
  48. Shortest Job First 194
  49. Shortest Remaining Time First 197
  50. Priority Scheduling, Starvation and Ageing 200
  51. Round Robin, and Choosing the Quantum 203
  52. Multilevel Queue Scheduling 206
  53. Multilevel Feedback Queue Scheduling 209
  54. All Seven Algorithms on One Problem 213
  55. Thread Scheduling, and What Linux Actually Does 217

Module II Deadlocks, Memory Management, Virtual Memory and Mass Storage, and the File System

  1. What a Deadlock Is, and the System Model 221
  2. The Four Conditions 225
  3. The Resource Allocation Graph 229
  4. The Four Ways to Handle a Deadlock 233
  5. Deadlock Prevention 236
  6. Safe States, and Avoidance 240
  7. The Banker's Algorithm 244
  8. The Resource Request Algorithm 248
  9. Deadlock Detection 252
  10. Recovery from Deadlock 257
  11. Why Memory Needs Managing 261
  12. Binding an Address: Compile, Load, Run 265
  13. The Memory Management Unit 269
  14. Swapping 273
  15. Contiguous Allocation, and the Holes It Leaves 277
  16. First Fit, Best Fit and Worst Fit 281
  17. Fragmentation, Internal and External 285
  18. Segmentation 289
  19. Paging 293
  20. Splitting an Address, and Translating One 298
  21. The TLB, and the Effective Access Time 302
  22. Protection and Sharing in a Paged System 307
  23. The Page Table Is Too Big: Hierarchical Paging 312
  24. Hashed and Inverted Page Tables 317
  25. Virtual Memory: Running What Will Not Fit 321
  26. Demand Paging, and the Page Fault 326
  27. The Effective Access Time Under Demand Paging 331
  28. Copy on Write 335
  29. Page Replacement: The Problem 340
  30. FIFO Replacement, and Belady's Anomaly 344
  31. Optimal Replacement 348
  32. LRU Replacement 351
  33. Second Chance, and the Counting Algorithms 355
  34. Comparing the Algorithms, and the Hit Ratio 360
  35. Allocation of Frames 364
  36. Thrashing, and the Working Set 368
  37. What a Disk Is, and What It Costs 373
  38. Disk Structure, and the Logical Block 377
  39. Disk Scheduling: FCFS and SSTF 381
  40. SCAN, C-SCAN, LOOK and C-LOOK 385
  41. Random Scheduling, and All Six Compared 389
  42. Disk Management 392
  43. What a File Is 397
  44. Opening a File, and What the Kernel Keeps 401
  45. Access Methods 405
  46. Directories, and the Shapes They Take 409
  47. Mounting 415
  48. File Sharing, and Locking 419
  49. The Layers a Read Passes Through 424
  50. On the Disk: Superblock, Inode, Data Blocks 428
  51. Directory Implementation 432
  52. Contiguous and Linked Allocation 436
  53. Indexed Allocation, and What a Real File System Does 441
  54. Free Space Management 446
  55. Designing a Small File System 451
munotes.in

The chapters

Every chapter of this book comes with the B.Sc. (Computer Science) Semester 3 notes.

The cover and the contents are free to look through. Buy the notes once to read every chapter of every subject in this semester.

Notes + practical solutions + solved papers: ₹798 Already bought it? Sign in

Or notes + practical solutions: ₹499
Or solved papers only: ₹499

Free either way: question papers, the syllabus, and the cover and contents of every book.

The rest of this subject

These notes are cut from the University's printed syllabus. Open the syllabus itself, or the past papers, for the same subject.

Issue
Done!