Coppia di semafori bislacchi: (S1,S2)

init(n1,n2);  Condizione: n1=0 /\ n2=1  ||   n1=1 /\ n2=0
Pb(Si);       Si comporta come una P normale, ma e' bloccante
              se non viene effettuata contemporaneamente una
              Vb(S[(i+1)%2])
Vb(Si);       Si comporta come una V normale, ma e' bloccante
              se non viene effettuata contemporaneamente una
              Pb(S[(i+1)%2])

======================================

Possibili stati e transizioni sono i seguenti:
                         Pb(S1)||Vb(S2)
                  (1,0)  ==============> (0,1)
                         <==============
                         Vb(S1)||Pb(S2)

Tutti gli altri tentativi di transizione sono bloccanti!

=======================================

A: Implementare i bislacchi con i semafori normali

int value1, value2;
inv inattesaV1, inattesaV2;
int sospesi1, sospesi2;
semaphore Mutex = 1;
semaphore Sem1 = 0;

init(n1,n2) {
   if (0 <= n1 <= 1  && 0 <= n2 <= 1 && n1 + n2 = 1) {
       value1 = n1; value2 = n2;
   } else ERROR
}

Pb(S1) {
  P(Mutex);
  if (value1 <= 0 || inattesaV2 == 0) {
    sospesi1++;
    inattesaP1++;
    V(Mutex);
    P(Sem1);  // passaggio del testimone
    sospesi1--;
    inattesaP1--;
  }
  value1--;
  if (sospesi2 > 0) {
    V(Sem2);
  } else V(Mutex);
}

Vb(S2) {
  P(Mutex);
  if(value2 >= 1 || inattesaP1 == 0) {
    sospesi2++;
    inattesaV2++;
    V(Mutex);
    P(Sem2); // passaggio del testimone
    sospesi2--;
    inattesaV2--;
  }
  value2++;
  if (sospesi1 > 0) {
    V(Sem1);
  } else V(Mutex);
}

=======================================

B: Implementare i semafori normali con i bislacchi

                         Pb(S1)||Vb(S2)
                  (1,0)  ==============> (0,1)
                         <==============
                         Vb(S1)||Pb(S2)


Passo 1: ci riconduciamo a implementare un semaforo binario con i
semafori bislacchi!

Tecnica A: rimuovere le limitazioni del semaforo bislacco

int value;
int <S1,S2>;  // Idea: il semaforo S1 e' il mio semaforo normale
init(1,0);

P() {
   cobegin {Vb(S2) || Pb(S1)}
}

V() {
   cobegin {Pb(S2) || Vb(S1)}
}