For those who have doubt about P1, when P1 goes to sleep() then it was placed in suspended list so when it will wake up it does not execute the whole down operation again but it will resume from that point of sleep() part and directly enters in critical section.
@@rahuldalal849 yes sir i added this comment after refering different website like stack overflow...i have the same doubt thats why i added here so others also understand
Awesome lec. Btw he forgot to mention one thing that p() and v() are atomic in nature. That is p and v are executed like a sngle statement by the processes; That is p() and v() are indivisible. Hope it makes sense.
thnx for this comment .....after watching the prev video I was wondering why we have multiple lines of code in semaphore wont preemption cause problems ......ty u cleared y doubt
Value of semaphore should be set to 1 in up section, even if the Block list is non empty, otherwise, the waking process won't be able to enter critical section
I believe in my concentration of learning the concepts of Operating System. Today I wrote my semester exam well with the help of your lectures sir🙏🙏🙏 I believe that I will get some knowledge along with your blessings through your lectures to achieve my goal as GATE TOPPER. Thanks alot !!!🤗
this year in barc 2021 exam one question reated to this topic has been asked and that question was - there were four options given and they were as follows -- a)down-v,signal b)up-p,wait c)down -p,wait d)none of these , so sir i learned all the cse subjects with ur videos only and it helps me a lot in my exam thankyou sir for ur great support to all ,,,,.love from patna
The processes in the suspend queue once tried to enter in the CS but failing to enter into CS were added to the suspend queue. When the current process finishes its execution and comes out of the CS, it does not make the semaphore 1, semaphore remains 0. As a result no new process (which has not tried to enter CS before) will be able to enter in the CS, rather they will get added up in the suspend queue. On the other hand the first process in the suspend queue(FIFO) will be fetched from the suspend queue will be transfered to the ready queue and it will get the chance to enter the CS directly without performing the wait() section. One process at a time should be fetched from the suspend queue so that there will be no conflict to enter in the CS.
Alright I might he wrong here but check this: Sleep is a function which stops execution of any process until it is woken up by any other process and wake up is function which wakes up sleeping process So let's say if P1 enters CS it will set S = 0 and when P2 wants to enter CS it will be put to sleep(you might think it is currently in an infinite loop). When P1 executes up code it will check if Suspend queue is empty. Since it's not cause of P2, it will wake up P2 from the point it was put to sleep i.e. from else code(you can also say that it breaks that infinite loop). Now you gotta understand that s is not the only factor that decides if process enters CS. For example, let's say there is no code in down, all processes wanting to enter CS will enter right, since there is no condition which blocks them Now understand that P2 will wake up and start executing from when it was set to sleep i.e. from else state, it will come out of 2 ending paranthesis and enter CS. Hope you understood what I said🤘
In comment section many people are thinking that there should be s.value =1 in the else part before wake up call for the process in up(s) ... just take these case at anytime the suspended list contains process p2,p3,p4 and process p1 is in cs now after execution in the cs it will have to go to the up(s) now in up(s) our process p2 is wake up() now when the p2 is set to sleep till that line all the execution is over so now p2 will directly go to the cs so the value of s should be 0 not 1 and thats why the code doesn't contain s.value=1 in the else part....now when all the p2,p3,p4 process get executed in the similar way the queue will become empty the value of s can be set as 1 and new process can enter into the cs.
Thanks! So will I be correct in saying that here the Down code is not working as an Entry code for critical section? In all previous examples, processes that failed to reach the critical section had to again follow entry code instructions.
As I understood, the code for UP in the video is correct. The state till which the process has been executed is stored while putting it into the block queue So when it is executed after P2 is executed, the process P1 will execute the remaining code , after the down function. Then after executing the critical section it will execute the up() function, that will update the S.value=1 . And the CPU will again reach the starting state
@@super_singing107 what if there are two processes in block state. And in else part you are assigning value = 1, so if some third process will execute down() now then it'll enter into the critical section but according to FIFO 2nd process which was blocked should get chance. Correct me if I am wrong?
considering 2 processes p1 and p2 , suppose p2 enters CS by down operation so it will make s=0 and when p1 executes down code it will go in suspended state , so when p2 executes up operation it will wake up p1 but value of s will be still 0 so how will p1 execute the down code because the value of s=0 still.
The state till which the process has been executed is stored while putting it into the block queue So when it is executed after P2 is executed, the process P1 will execute the remaining code , after the down function. Then after executing the critical section it will execute the up() function, that will update the S.value=1 . And the CPU will again reach the starting state. [I copied this answer from sayanta bhattacharjee, He answered it just perfectly..]
@@upasonabiswas6783 so if p1 was in block list then S=0 and suppose p2 finishes executing then it will goto exit section code it will just wakeup p1 but how is it making s=1 again it's only going to do that if the list was not empty! If you find anything wrong correct me
I found these tutorials but then I started to see some similarities in the diagrams that my prof presented. I checked those ppt's and realized my prof had used your examples as screenshots in her ppt
just because u r HUMBLE and u made it easy for me to understand....i like it & subscried ur channel.......GREAT STUFF........would love to have some lectures on C Programming.
Code is absolutely correct.. sir might forgot to mention that the suspended process will restart from the same point where it got stopped last.. thank you for this series sir.. ❤️❤️
In case a process is in the waiting queue, you have mentioned in the Down code that we'll wake it up, and that's all good, but I think after waking it up we also have to set S to 1 so that the newly awakened process could enter the critical section.
Else block in UP should be updated as follows Select a process and wake up //Chk again If (list is empty) S.value = 1 The only the value of semaphore can be made 1 again To allow other process to enter in CS .
For those who have confusion p1,p2,p3 processes are there imagine p1 enters the CS (critical section ) first so S=0 then p2 and p3 tries to enter into CS but cant bcz s=0 and p2 ,p3 goes to block stage now p1 finished executing its CS then it will execute the UP so acco to fifo p2 is removed from blocked stage and is allowed to enter into its CS ( ie p2 got blocked in the last line of DOWN function so when p2 is wake up it will start executing from the next line (after sleep() ) the next line after DOWN function is CS section ) p2 will start executing from the point it got blocked not from beginning
Sir, please clear my doubt, when a process P1 wake up, then also Semaphore value is 0, then how it will enter into critical section, instead of this, It will again go back to suspend list.
At 7:05 you said if a process is exiting Critical Section and S = 1. How S can be 1 if there is a process in Critical Section in the case of Binary Semaphore ?
In case if you're wondering if the up function is wrong, it is not. Code is correct. Once the suspended process is wakened up, it will directly execute the critical section, it will not execute the down function as it has already been executed.
noh youre wrong, after wake up, it sent to waiting queue means it can again try to get executed, but the code is wrong as the value of s remains 0 in up() code, so its not going to get executed for more information contact your os teacher...
In binary semaphore only one process can access the Critical section at a time so if that process run the UP code while exiting from Critical section S will be set to 1 again but there won't be another process to overwrite value of S to 1.So at 4.29 we are considering two possibilities that value of S will be 0 or 1 that might be wrong there might be only one possibility and that is value of S is 0.
If we add in ready queue and we are not setting S.value=1 in else part it will be a deadlock situation right? This code makes sense if we are directly adding from Suspended list to Critical Section else the code should be like this Up( Semaphore S ) { S.value=1; if (!Suspended list is Empty){ Select a process from suspended List; Wake up(); }
no there will be no deadlock situation, in that code when p2 is going to sleep it is executing the last instruction in the down(S), so after it will wake up it will directly enter into the critical section because it will resume it will not execute down(S) again.
@@paulsnehasish5830 Doesnt make sense to me. The s.value was 0 thats why the process went into suspend queue.else part will get executed by the process leaving the cs(still the s.value is 0). One solution is that the program which dequeues the processes from the suspend queue sets the s.value to 1 before dequeing;
@@suryasikharej8116 it doesnt need to set the value to 1 because the blocked processes will get inti the CS upon waken up....once a process executes previous codes it wont execute them again...it will resume from the blocked state and will go to the CS directly
@@paulsnehasish5830 No a process can never get to critical section directly. It needs to get into the ready queue and if another process comes with higher priority than the dequeued one then that process will also get stuck because s.value is still 0;
Sir i have a doubt... See if suspended process will wake up and then it will try to be executed but it will blocked again then up process will work then down then up... Yeh to chlta hi rhega😂 agar koi process esa hain to kya hoga agli process ki baari kaise ayegi
Okay I see people a bit confused regarding the UP code in the comment section. The code is absolutely correct. A process which wakes up after sleep will start its execution from the point it left before the sleep. In the example used in the video, P2 runs the DOWN code and changes value of s from 1 to 0. Now when P1 comes it finds s = 0 and goes to sleep. When P2 runs the UP code it wakes up P1 and s still remains 0. We cannot change s here as P1 is still not inside the critical section but just woke up. Thus, P1 goes to critical section after waking up even though value of s = 0. Now you may wonder when will s become 1, simply when P1 runs its UP code ( i.e. when suspend list is empty) . In a nutshell, you need to understand that s = 1 is not the only condition that can make a process go inside the critical section. Generalize this example for 5 processes and you are good to go.
So why sleep() doesn't perform like it should in the previous video. Bhaiya said the process again waking up are now eligible to try to enter critical section
For example there are two processes p1 and p2 p1 run down code check the condition s==1 it is true then suddenly it is pre empted now p2 run and check the condition the condition is true and p2 is in critical section now and then p1 is resumed it is also in critical section mutual exclusion is violated here
As explained in previous video, every solution should follow mutual exclusion. And binary semaphore does follow it as only one process get access of the critical section. But what about counting semaphore? Many process where there inside the critical section just because semaphore value was more than 1. How we can say that counting semaphore is a solution when its not following the primary condition?
Counting semaphore only allows mutual exclusion when we initialize semaphore value to 1. If it's more than 1, then mutual exclusion cannot be guaranteed.
Many thanks for such beautiful videos sir... Sir I have one doubt.. suppose p1 satisfy condition s.value==1 and before entering in block it get preemptive...and now p2 also satisfies condition and enters in critical section and now p1 comes back...then what would happen??
I watched your 4-5 videos and now I want to ask : by any chance do you teach for UGC net ? If you have paid classes kindly let me know I want to join as soon as possible.....and thanks for the wonderful explanation 🙏
For binary Semaphore it is not possible to enter critical section as no P() is performed but possible in case of counting Semaphore if prior a P() is performed.
(To all the people who say code is incorrect) The code int the video is correct. When a process is woke up from Suspend list it goes back into Ready Queue.(Note the P1, P2 shown in ex were at the execution time).Whenever process'es enter from Ready to Run Queue The Semaphore values get initialized.
If you are correct then for the first time when P1 interfere P2 (Ready state to running state) then Semaphore value should have been initialized again as S=1 but since Semaphore is shared resource it did't initialize.
@@sakshijain5503 See the interfering processes first go into suspend list, and then when woke up goes to ready queue. (We assumed the processes coming are of same priority). Let's say p1,p2,p3 came concurrently ,say p2 entered CS, p1,p3 goes to suspend queue, again when cpu goes back to p1 n p3 it puts them in ready queue (pops until list Is empty) now semaphore value is set as 1. //Correct me if I'm wrong.
if there are several processes p1, p2, p3 .......pn then if S = 1 the process p1 will go into critical section to wait queue there will a condition do { if (S
NIT I Introduction: Concept of Operating Systems, Generations of Operating systems, Types of Operating Systems, OS Services, System Calls, Structure of an OS - Layered, Monolithic, Microkernel Operating Systems, Concept of Virtual Machine. Case study on UNIX and WINDOWS Operating System. Processes: Definition, Process Relationship, Different states of a Process, Process State transitions, Process Control Block (PCB), Context switching Thread: Definition, Various states, Benefits of threads, Types of threads, Concept of multithreads, UNIT II Process Scheduling: Foundation and Scheduling objectives, Types of Schedulers, Scheduling criteria: CPU utilization, Throughput, Turnaround Time, Waiting Time, Response Time; Scheduling algorithms: Pre-emptive and Non pre-emptive, FCFS, SJF, RR; Multiprocessor scheduling: Real Time scheduling: RM and EDF. Solution, Inter-process Communication: Critical Section, Race Conditions, Mutual Exclusion, Hardware Solution, Strict Alternation, Peterson‘s The Producer\ Consumer Problem, Semaphores, Event Counters, Monitors, Message Passing, Classical IPC Problems: Reader‘s & Writer Problem, Dinning Philosopher Problem etc. UNIT III Deadlocks: Definition, Necessary and sufficient conditions for Deadlock, Deadlock Prevention, Deadlock Avoidance: Banker‘s algorithm, Deadlock detection and Recovery. Memory Management: Basic Fixed and concept, Logical and Physical address map, Memory allocation: Contiguous Memory allocation variable partition- Internal and Page allocation -Hardware support for External fragmentation and Compaction; Paging: Principleof operation - paging, Protection and sharing, Disadvantages of paging. UNIT IV Virtual Memory: Basics of Virtual Memory - Hardware and control structures - Locality of reference, Page fault , Working Set , Dirty page/Dirty bit - Demand paging, Page Replacement algorithms: Optimal, First in First Out (FIFO), Second Chance (SC), Not recently used (NRU) and Least Recently used (LRU). I/O Hardware: I/O devices, Device controllers, Direct memory access Principles of I/O Software: Goals of Interrupt handlers, Device drivers, Device independent I/O software, Secondary-Storage Structure: Disk structure, Disk scheduling algorithms UNIT V File Management: Concept of File, Access methods, File types, File operation, Directory structure, File System structure, Allocation methods (contiguous, linked, indexed), Free-space management (bit vector, linked list, grouping), directory implementation (linear list, hash table), efficiency and performance. Disk Management: Disk structure, Disk scheduling - FCFS, SSTF, SCAN, C-SCAN, Disk reliability, Disk formatting, Boot-block, Bad blocks
At up operation, S.value can never be 1. So, no chance of S.value to overwrite/remain 1. But if entry and exit codes are defined differently, eg. Entry = v(mutex) and exit = p(mutex) then you would see mutex = 1 at up operation Reference: next video in playlist
Hi, please improve your video related to Counting Semaphore. I could not understand the need for counting semaphore as it does not allow for mutual exclusion that is the fundamental need for synchronization. However, after reading from Quora, i got to know that Counting Semaphore is useful when a resource needs to be used strictly by only N processes. I hope you will add more to the previous video to clear the confusion.
After a down and up series of operations are carried out and executed. What about resetting semaphore value? from 0 to 1 for next set of processes to be cleared.
How will semaphore value be reset to 1 , Because after performing an up operation p2 will leave critical section and p1 will be sent to ready state , but s is still 0
