[Kos-dev] Re: [Kos-cvs] [kos] Modification CVS par thomas

[Christophe]

C'est le mécanisme de synchronisation non-bloquante CAS (compare-and-swap).

bool cas (int *memory_slot,int requested_value,int new_value) {
    atomic {
        if (*memory_slot == requested_value) {
            *memory_slot = new_value;
            return true;
        }
        return false;
    }
}

En clair, on modifie la valeur à l'emplacement de la mémoire si et seulement
si on lit bien la valeur attendue.

C'est une opération atomique de lecture-écriture, sauf que l'écriture est
conditionnel.

cmpxchg fait partie de la famille CAS à une différence près :

bool cmpxchg (int *memory_slot,int &old_value,int new_value) {
    atomic {
        if (*memory_slot == old_value) { // la valeur lue correspond à celle
qu'on attend
            *memory_slot = new_value; // on écrire la nouvelle valeur
            return true;
        }
        old_value = *memory_slot;  // on retourne dans le registre la valeur
lue
        return false;
    }
}

Dans mon exemple, je vérifie que personne d'autre n'a modifié la valeur du
PTE entre le moment où je lis sa valeur dans requested_value et l'exécution
effective de 'cmpxchg' : en fait, je veux m'assurer que personne n'est venu
locké avant que mon 'cmpxchg' ne l'ait fait. C'est pour ça qu'il faut
requested_value.

Ce qui se passe c'est que le processeur à exécuter en premier le 'cmpxchg'
obtient pour lui le verrou. Ceux qui ont déjà lu la valeur de ce PTE comme
étant non vérouillé avant lui verront ensuite grâce à leur 'cmpxchg' qu'un
notre processeur leur a damer le pion entre temps : ces processeurs
continuent donc de boucler jusqu'à ce que le processeur qui a obtenu le
verrou relâche. Le premier des autres processeurs à exécuter le 'cmpxchg'
obtient à son tour le verrou, etc.


----- Original Message -----
From: Thomas Petazzoni <thomas.petazzoni@enix.org>
To: <kos-dev@enix.org>
Sent: Thursday, February 21, 2002 7:17 PM
Subject: Re: [Kos-dev] Re: [Kos-cvs] [kos] Modification CVS par thomas


> "Christophe" <christophe.avoinne@laposte.net> writes:
>
> > int lock_pte (unsigned long *pte) {
> >     unsigned long requested_value,new_value,eflags;
> >     eflags = save_eflags_and_cli ();
> >     while (1) {
> >         if ((requested_value = *pte) & PTE_LOCKED)
> >             continue;
> >         new_value = requested_value | PTE_LOCKED;
> >         if (cmpxchg (pte,requested_value,new_value))
> >             break;
> >     }
> >     return status;
> > }
>
> Pas mal l'idee d'utiliser un des bits "Available for programmer use"
> pour locker les PTE. Peut etre que l'utiliser au niveau des PDE
> permettrait de locker avec un grain plus fin. Mais AMHA ca sera utile
> qu'au niveau de l'espace user, parce que au niveau kernel avec la
> synchronisation entre tous les PDs c'est peu la merde !
>
> Par contre je vois pas bien a quoi sert ton requested_value... C'est
> la valeur attendue dans le PTE ?
>
> Bref si tu pouvais commenter un peu plus, ca pourrait m'etre utile ;)
>
> Thomas
> --
> PETAZZONI Thomas - thomas.petazzoni@enix.org - UIN : 34937744
> (Perso)      http://www.enix.org/~thomas/
> (KOS)        http://kos.enix.org/
> (Club LinUT) http://club-linut.enix.org
>
> _______________________________________________
> Kos-dev mailing list
> Kos-dev@doors.enix.org
> http://the-doors.enix.org/cgi-bin/mailman/listinfo/kos-dev
>