Critical Section Problem

Critical section refers to a segment of code that is executed by multiple concurrent threads or processes, and which accesses shared resources. These resources may include shared memory, files, or other system resources that can only be accessed by one thread or process at a time to avoid data inconsistency or race conditions. In other words, when more than one processes try to access the same code segment that segment is known as the critical section.

  • For example, imagine you are using an online banking system, where you can perform various tasks like transferring money, checking your account balance, and paying bills. Now, consider that many users are accessing their bank accounts at the same time. 
  • The system must ensure that every user's transactions are processed accurately and without any interference from other users. In this system, each user represents a process. For example, when you log in to transfer money, your session is one process. At the same time, other users are also logged in and performing their own transactions, each represented by their own processes. 
  • The critical section in this context is the part of the code where the bank updates the account balance. For example, when you transfer $100 to someone, the system checks your balance, deducts $100, and then updates your account with the new balance. 
  • Suppose two users, User A, and User B, both have access to the same joint bank account, which has a balance of $200. If User A and User B both try to transfer $100 out of the account at the exact same time, here's what could go wrong:
  • User A’s process checks the balance (sees $200) and decides to deduct $100. Simultaneously, User B’s process also checks the balance (also sees $200) and decides to deduct $100. Both processes think there's enough money and proceed to make the deduction. However, both processes might update the balance separately, each thinking the balance is now $100. The final result could be that the bank account shows $100, but actually, $200 was deducted, which means $100 disappeared due to the incorrect handling of simultaneous access. This is an example of race condition where the outcome depends on the unpredictable timing of processes, which can happen if multiple processes enter the critical section simultaneously.
  • To prevent this, the operating system ensures that when one person (process) is accessing the critical section (the part of the code handling the balance), no one else can access it at the same time. This is done using synchronization mechanisms like locks or semaphores.

The main requirements for solving the critical section problem are often referred to as the Critical Section Design Criteria:

  1. Mutual Exclusion: Only one process can be in the critical section at any given time.
  2. Progress: If no process is in the critical section and there are processes that wish to enter, then one of the waiting processes should be allowed to enter the critical section.
  3. Bounded Waiting: A process should not have to wait indefinitely to enter the critical section. There must be a limit on the number of times other processes are allowed to enter the critical section before the waiting process gets its turn.

Comments

Post a Comment

Popular posts from this blog

Indexed allocation

Image
  Indexed allocation is a file allocation method used by operating systems to manage how files are stored on disk. The core idea is simple but powerful: instead of storing a file in contiguous blocks or linking blocks one-by-one, the system uses a special index block that contains a list of all the disk block addresses where the file’s data is stored. This removes many limitations of earlier methods like contiguous and linked allocation. In indexed allocation, each file has its own index block . This index block acts like a table of contents. Every entry inside it points to a data block that belongs to that file. When a file is created, the OS allocates an index block and then fills it with pointers to the actual data blocks as the file grows. These data blocks can be located anywhere on the disk , so the file does not need contiguous space. This makes storage much more flexible and avoids external fragmentation. When the system needs to access a particular part of a file, it fir...
Read more

Thrashing

Image
Thrashing occurs in a computer system when the operating system spends a significant amount of time swapping pages in and out of memory, rather than executing actual processes. This typically happens when the system's memory is overcommitted, meaning there are too many processes competing for too little physical memory, leading to frequent page faults. How Memory is Used 1. Initial State: App1 is running, and its two pages are loaded into memory: Frame 1: App1, Page 1 Frame 2: App1, Page 2 Frame 3 and 4 are free. App3's pages are present in swap memory. 2. Switch to App2: Now, you switch to App2, which also requires 2 pages: Frame 3: App2, Page 1 Frame 4: App2, Page 2 Memory is now full with both App1 and App2’s pages. App3's pages are present in swap memory. 3. Switch to App3: You decide to switch to App3, which needs 2 pages as well. Since the memory is full, the system needs to make room: App1’s pages are moved to swap memory: Swap Memory: [App1, Page 1] [App1, Page 2] F...
Read more

Basics of paging

Image
Paging is a memory management scheme that eliminates the need for contiguous allocation of physical memory and thus helps in handling fragmentation. It involves breaking down memory into fixed-size blocks called pages and frames. The OS typically decides the page size when the system is configured or during the OS design phase. This page size is constant for the entire system and is determined based on considerations such as hardware architecture, efficiency, and the type of applications running. Common page sizes are 4 KB, 8 KB, or 16 KB. Here's a simple explanation with an example: Basic Concepts Page: A fixed-size block of logical memory (virtual memory) used by a process. Frame: A fixed-size block of physical memory (RAM) where a page is mapped. Page Table: A data structure used by the operating system to keep track of the mapping between pages and frames. The Page Table Base Register (PTBR) is a special register in the CPU that holds the starting address of the page table for ...
Read more