Comment utiliser test-and-set () pour résoudre le problème de la section critique?

Question

Je suis étudiant pour un examen et je vais avoir du mal avec un concept. Ce code est le pseudo que je me donne:

int mutex = 0;
do {
  while (TestAndSet(&mutex));
  // critical section
  mutiex = 0;
  // remainder section
} while (TRUE);

Mon instructeur dit que l'on rencontre ce code, mais je ne comprends pas que l'on n'est pas satisfaite que deux des trois conditions nécessaires (exclusion mutuelle, les progrès, et bornés en attente) ... ??

Comment le code soit modifié pour supporter la condition manquante pour résoudre le problème de la région critique? Merci d'avance pour toute perspicacité!

Answer 1

Si quelqu'un voit la recherche de la réponse, le code ci-dessus ne prend pas en charge attente limitée (il doit y avoir une limite sur la quantité de temps un processus doit attendre). Ce code est correct pour assurer les trois conditions sont réunies pour assurer synchronyzation en utilisant SetAndTest:

do{
  waiting[i] = TRUE;
  key = TRUE;
  while(waiting[i] && key)
    key = TestAndSet(&lock);
  waiting[i] = FALSE;

  // Critical Section

  j = (i + 1) % n;
  while ((j != i) && !waiting[j])
    j = (j+1) % n;

  if (j == i )
    lock = FALSE;
  else
    waiting[j] = FALSE;

  // Remainder Section
} while (TRUE);

Answer 2

D'abord joli petit exemple, mais prend args booléennes test-and-set et par défaut mutex est réglé sur FALSE. Alors int mutex=0 est en fait boolean mutex=FALSE.The code ci-dessus ne dispose d'exclusion mutuelle et des progrès mais pas d'attente limitée. De plus, votre définition de testandset est erroné. Il devrait être target=TRUE et non target=TRUE.

Answer 3

Est-ce parce que le mutex doit être réglée à l'aide des instructions de chargement et de stockage atomiques pour que l'accès mémoire n'est pas réorganisés? exécution atomique d'un ensemble d'instructions signifie que le les instructions sont traitées comme une seule étape ne pouvant pas être interrompue.

// example process using mutual exclusion
void process() {
  int mutex;
  init_lock (&mutex);
  do {
    lock (&mutex);
    // critical section
    unlock (&mutex);
    //remainder section
  } while(TRUE);
}

// mutual exclusion functions
void init_lock (int *mutex) {
  *mutex = 0;
}

void lock (int *mutex) {
  while(TestAndSet(mutex))
}

void unlock (int *mutex) {
  *mutex = 0;
}

int TestAndSet(*target) {
  int rv = *target;
  *target = 1;
  return rv;
}

Il suffit de regarder, il semble que les fonctions font la même chose que l'exemple de code affiché plus tôt, mais je suppose que cette façon assure l'exclusion mutuelle parce que les fonctions d'exploitation sur la cible de * sont atomiques ... ??

Excusez les fautes de frappe ...

Answer 4

Délimité attente n'est pas remplie ici. vous pouvez le voir, il doit être lié au nombre de fois qu'un processus particulier peut aller dans la section critique, afinde pour éviter la famine d'autres processus ... et il doit y avoir une limite du temps un processus doit attendre