Can we use one variable - turn only in Peterson's solution?

Here is the Peterson's solution presented in our lecture:

//P0:

do {
  flag[0] = TRUE; turn = 1;
  while(flag[1] && turn == 1);

  //Critical section
  flag[0] = FALSE;
  //remainder section
} while(1)


//P1:

do {
  flag[1] = TRUE; turn = 0;
  while(flag[0] && turn == 0);
  
  //critical section
  flag[1] = FALSE;
  //remainder section
} while(1)

Doesn't the turn variable itself already guaranteed the requirements for critical section? Like the flag[] here seems unnecessary.

The flag array specifies for each process whether it is currently interested in the critical section (i.e. whether it currently desires to enter it or is already inside it). This information is necessary for the following reason:

Assuming that process #0 desires to enter the critical section, it must know whether process #1 is currently also interested in the critical section, because process #0 must act differently depending on whether process #1 is also interested in the critical section.

If process #1 is not interested in the critical section, then process #0 should not wait for process #1 to set turn to 0, because it may wait indefinitely for this to happen, which would violate the "progress" and "bounded waiting" requirement. Instead, process #0 should simply enter the critical section in that case.

If process #1 is interested in the critical section, then process #0 should wait for process #1 to either

• leave the critical section (which process #1 indicates by setting flag[1] to false), or
• yield to process #0 (which process #1 indicates by setting turn to 0).

Otherwise, the "mutual exclusion" requirement would be violated.

While the accepted answer provides a good explanation of Peterson's algorithm and justification of why both turn and flag are needed, this analysis can also be carried out in a more "hands on" fashion by trying to eliminate the flag variable from the algorithm while maintaining the key properties mutual exclusion, progress, and bounded waiting.

Just deleting all statements with flag leaves the obvious problem that if e.g. P0 sets turn=1 and starts waiting while turn==1 then it will wait indefinitely unless P1 sets turn=0. Hence the "progress" property is lost.

Let us try to repair it by instead setting turn to "my" value ("0" for P0 and "1" for P1) and wait until turn has "my" value. This clearly requires setting the turn to the value of the "other" process when exiting the critical section (otherwise, the "other" process could be waiting indefinitely in its while-loop, losing the "bounded waiting" property):

//P0:

do {
  turn = 0;
  while(turn != 0);

  //Critical section

  turn = 1;  // Done with critical section, let P1 have a go
  //remainder section
} while(1)


//P1:
do {
  turn = 1;
  while(turn != 1);
  
  //critical section

  turn = 0;  // Done with critical section, let P0 have a go
  //remainder section
} while(1)

However, this does not ensure the "mutual exclusion" property: while e.g. P0 is in its critical section, P1 can happily set turn=1 and proceed to its critical section.

The lesson learned is: be very careful when it comes to concurrency. There are opportunities for mistakes everywhere and they can be difficult to see while coding and even more difficult to troubleshoot afterwards. Whenever possible, embrace established methods like Peterson's Algorithm which have been analyzed and optimized thoroughly over the years.