I am confused as to how the two binary semaphores Q and S are used to both guarantee equal execution and create the possibility of starvation in the following example I was referencing.
The rationale for there being guaranteed equal execution in the middle example is that:
The second guarantees equal shares since the process that holds both Q and S will give up S to the other process before it releases Q and goes back to the top of the loop.
I don't really understand what "give up S to the other process" means. Isn't S just a value to be incremented and decremented? Where is the idea that P1 will run after S is signaled coming from?
The explanation for the third case being subject to starvation doesn't really make sense to me either, saying:
The third is subject to starvation, since it's possible for one process to run slightly faster than the other and monopolize the semaphores.
If it's possible for one process to monopolize the semaphores in this case, then couldn't the same be said for the case of equal execution? What makes these different in that sense?
hey so the difference occours from the order of the signal cases
in the equal work case we are incrementing the value of s , basically we are giving away the control of S . here this is a shared variable once a process executes wait(S) it is as good as taking control of that semaphore , so signal here refers to giving up the control to some other process
now coming to the starvation issue , remember there are hundereds of process in a pc . so if we assume there is a process P3 with the following code
p3 while (1){ wait(Q) //critical section signal(Q)
because P1 is first giving up Q here and if p3 is slighly faster at exection that p2 it will get hold of Q . now after another context switch say p2 gets control it can effectively get S because it is free and no process was faster than it it starves because it cannot get Q because p3 has it
hence it is starved