Read Write problem

What is the read-write problem?

Threads Involved:

  • Reader Threads: Read the shared resource without modifying it.
  • Writer Threads: Modify or update the shared resource.

Rules for Safe Access:

  • Multiple Readers: Multiple reader threads can read the resource simultaneously without causing inconsistencies, as long as no writer is updating the resource.
  • Single Writer: Only one writer thread should be allowed to modify the resource at a time. During this period, no other readers or writers should access the resource.

File Example:

  • Multiple Writers: If two writers, W1 and W2, are writing to the same file simultaneously, they can corrupt or overwrite each other's changes, leading to data inconsistency. This is because the file might end up with mixed or incorrect data if both writers modify it at the same time. 
  • Reader and Writer Interaction (Concurrent Reading and Writing): 
  1. If a reader, R1, reads from a file while a writer, W1, is updating it, the reader might see a partially updated or inconsistent state of the file. 
  2. For instance: Writer W1: Writes "ABCD" to the file. Reader R1: Reads the file and sees "ABCD".
  3. Before R1 finishes: Writer W1 updates the file to "ABCE".
  4. R1's Read: If R1’s read operation is not synchronized with W1’s write operation, R1 might have read outdated data or a mix of old and new data, leading to inconsistency.
Why Synchronization is Needed: 
  • Inconsistency: Without proper synchronization, the file could end up with inconsistent data due to simultaneous writes or incorrect reads when the file is being modified.
  • Race Conditions: Occur when multiple threads access or modify shared data without proper coordination, leading to unpredictable outcomes.
The solution to this problem

Semaphores Used:
  • Binary Semaphore (wrt): This semaphore controls access to the critical section where the shared resource is modified. It ensures that only one writer can access the resource at a time, and it also ensures that no readers are accessing the resource while a writer is writing.
  • Count Variable (read_count): This variable keeps track of the number of readers currently accessing the shared resource.
Writer Thread:
Before Entering the Critical Section: wait(wrt), the writer performs a wait operation on the wrt semaphore. If wrt is 1 (available), the writer can enter the critical section. If wrt is 0 (indicating a writer is currently in the critical section), the writer will be blocked and wait until wrt becomes available.
Writing Operation: The writer performs the write operation to modify the shared resource.
After Exiting Critical Section: signal(wrt), after finishing the write operation, the writer performs a signal operation on the wrt semaphore. This operation releases the semaphore, allowing other writers or readers to enter the critical section.
Reader Thread:
  1. Entering Critical Section: 
  • wait(mutex): The reader acquires the mutex to safely access and modify readcount.
  • Update readcount: Increment the readcount variable to reflect that a new reader is entering. If readcount was 0 before, this indicates that no readers were in the critical section, so the reader needs to check if a writer is currently active:
  • wait(wrt): If readcount was 1 (i.e., the first reader), this operation blocks any writers from entering the critical section, ensuring that readers can access the resource without interference.
  • signal(mutex): Release the mutex after updating readcount to allow other readers or threads to access readcount.
  • Reading Operation: The reader performs the read operation.
      2. Exiting Critical Section:
  • wait(mutex): The reader acquires the mutex again to safely update readcount as it leaves.
  • Update readcount: Decrement the readcount variable. If readcount becomes 0 (indicating no more readers are in the critical section):
  • signal(wrt): Release the wrt semaphore to allow any waiting writers to enter the critical section.
  • signal(mutex): Release the mutex after updating readcount.

























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