la logique de séparation concurrente

Logiques de programmes, quatri`eme cours

Parall ´elisme `a m ´emoire partag ´ee : la logique de s ´eparation concurrente

Xavier Leroy 2021-03-25

Coll`ege de France, chaire de sciences du logiciel [email protected]

Introduction : Le calcul parall `ele

`a m ´emoire partag ´ee

Le calcul parall `ele

Faire travailler ensemble plusieurs unit´es de calcul (CPU) pour effectuer une tˆache plus rapidement.

Deux principales modalit´es du parall´elisme :

`a m´emoire partag´ee `a m´emoire distribu´ee

bus CPU CPU CPU CPU

RAM

r´eseau CPU

RAM

CPU RAM

CPU RAM

CPU RAM De nombreuses r´ealisations combinant les deux mod`eles : multicœurs, multiprocesseurs, GPU,clusters,grids,cloud, . . .

Quelques dates dans l’histoire du calcul parall `ele

1962 Premier multiprocesseur sym´etrique : le Burroughs D825 (1 `a 4 CPUs partageant 1 `a 16 modules m´emoire).

1965 D´ebut du projet Multics, le premier syst`eme d’exploitation moderne avec support pour multiprocesseurs.

1973 Xerox Parc : stations de travail Alto + r´eseau Ethernet.

Premier gros calcul distribu´e (rendu d’images).

1999 Lancement de SETI@home et de Folding@home, deux ´enormes calculs distribu´es sur Internet .

2006 Premiers processeurs multicœursgrand public (Intel Core Duo et AMD Athlon 64 X2).

2012 (environ) Tous les processeurs pour PC, tablettes et smartphones sont multicœurs.

Le parall ´elisme `a m ´emoire partag ´ee

Int´erets :

• Tous les processeurs ont acc`es direct `a toutes les donn´ees.

• Pas de duplication des donn´ees.

• Communications tr`es rapides (via des zones de m´emoire partag´ee).

Difficult´es :

• Risque d’interf´erence entre les actions des processeurs.

• En particulier : les courses critiques (race conditions).

Course critique (race condition)

Plusieurs acc`es simultan´es `a la mˆeme case m´emoire, dont au moins un acc`es en ´ecriture.

Cas 1 : deux ´ecritures simultan´ees.

set(`,1) set(`,2)

Le programme ne contrˆole pas quelle valeur finit dans la case`. Cas 2 : ´ecriture et lecture simultan´ees

set(`,1) letx=get(`)

Le programme ne contrˆole pas quelle valeur est lue dansx.

Un exemple de course critique

x:=x+₁ x:=x+₁

Compil´e en 3 instructions (lecture, calcul, ´ecriture) : lett=get(&x)in

lett=t+₁in set(&x,t)

lett=get(&x)in lett=t+₁in set(&x,t)

Un exemple de course critique

x:=x+₁ x:=x+₁

Une ex´ecution possible : lett=get(&x)in lett=t+₁in set(&x,t)

lett=get(&x)in lett=t+1in set(&x,t) Avecx=0 initialement, on termine surx=2.

Un exemple de course critique

x:=x+₁ x:=x+₁

Une autre ex´ecution possible : lett=get(&x)in lett=t+₁in

lett=get(&x)in set(&x,t)

lett=t+1in set(&x,t) Avecx=0 initialement, on termine surx=1.

Un exemple plus r ´ealiste

La partieproducteurd’un sch´ema producteur/consommateur : chaque processus produit des donn´eesxet les stocke dans un tampon partag´eT(un tableau de tailleNindex´e pari).

whilei≥Ndo pause();

T[i] :=x; i:=i+₁;

Un exemple plus r ´ealiste

Avec deux producteurs en parall`ele :

whilei≥Ndo pause();

whilei≥Ndo pause();

T[i] :=x₁; i:=i+₁; T[i] :=x₂; 8

i:=i+₁;

Risque d’acc`es hors borne dans le tableau (sii=N−1 initialement).

Un exemple plus r ´ealiste

Avec deux producteurs en parall`ele :

whilei≥Ndo pause();

whilei≥Ndo pause();

T[i] :=x₁;

T[i] :=x₂; i:=i+1; i:=i+₁;

Une des deux donn´eesx₁,x₂est perdue.

L’entr´eeT[i−₁]du tableau n’est pas initialis´ee.

Synchronisation par sections critiques

En Java : En C :

synchronized (obj) { pthread_mutex_lock(mut);

... ...

} pthread_mutex_unlock(mut);

Garantissent l’exclusion mutuelle: `a tout moment au plus un processus ex´ecute la section critique.

Exemple : un producteur bien synchronis´e.

synchronized (buff) {

while (buff.i >= N) buff.wait();

buff.T [ buff.i ] = x;

buff.i ++ ; }

Synchronisation et logiques de programmes

De nombreux m´ecanismes de synchronisation :

• exclusion mutuelle : s´emaphores, verrous, . . .

• barri`eres et vagues de calcul ;

• passage de messages ;

• instructions atomiques des processeurs ;

(→algorithmeslock-free)

Quelles logiques de programmes pourraisonner sur

l’interf´erenceetgarantir la bonne synchronisation, notamment l’absence de courses critiques?

Parall ´elisme sans partage de

ressources

Ex ´ecuter deux commandes en parall `ele

Commandes : c:=. . .

|c₁kc₂ ex´ecutec₁etc₂en parall`ele

S´emantique : unentrelacementdes r´eductions dec₁etc₂. (a₁ka₂)/h→₀/h (ou toute combinaison dea₁eta₂)

(c₁ kc₂)/h→(c⁰₁kc₂)/h⁰ sic₁/h→c⁰₁/h⁰ (c₁ kc₂)/h→(c₁kc⁰₂)/h⁰ sic₂/h→c⁰₂/h⁰

(c₁ kc₂)/h→err sic₁/h→errouc₂/h→err

La r `egle de s ´eparation pour l’ex ´ecution parall `ele

{P₁}c₁{λ .Q₁} {P₂}c₂{λ .Q₂} {P₁V^P2}c₁kc₂{λ .Q₁V^Q2} Intuition :

• l’´etat m´emoire initialhse d´ecompose enh₁]h₂avech₁ satisfaisantP₁eth₂satisfaisantP₂;

• c₁s’ex´ecute dansh₁sans modifierh₂;

• c₂s’ex´ecute dansh₂sans modifierh₁;

• les ´etats finauxh⁰₁,h⁰₂satisfontQ₁,Q₂et sont disjoints.

La r `egle de s ´eparation pour l’ex ´ecution parall `ele

{P₁}c₁{λ .Q₁} {P₂}c₂{λ .Q₂} {P₁V^P2}c₁kc₂{λ .Q₁V^Q2} Autre intuition : la pr´econditionP₁V^P₂garantit que les commandesc₁etc₂s’ex´ecutent sans interf´erences.

L’ex´ecution est donc s´emantiquement ´equivalente `a une ex´ecution s´equentiellec₁;c₂ouc₂;c₁.

{P₁}c₁{λ .Q₁} {P₁V^P₂}c₁{λ .Q₁V^P₂}

{P₂}c₂{λ .Q₂} {Q₁V^P₂}c₂{λ .Q₁V^Q₂} {P₁V^P₂}c₁;c₂{λ .Q₁V^Q₂}

Parall ´elisme s ´epar ´e entre sous-tableaux

Exemple : le tri Quicksort.

quicksort T l h= ifh−l≤₂₀then

insertionsort T l h else

letm=partition T l hin

quicksort T l mkquicksort T(m+₁)h quicksort T l hmodifie le sous-tableauT[l. . .h]_deT.

Les deux appels r´ecursifs se font sur des sous-tableaux disjoints : T[l. . .m]_etT[m+₁. . .h]_.

On peut donc les faire soit en s´equence soit en parall`ele.

Parall ´elisme s ´epar ´e entre sous-arbres

tree(Leaf,p) =hp=NULLi

tree(Node(t₁,x,t₂),p) =∃p₁,p₂, p7→p₁V^p+₁7→x V^p+₂7→p₂ V^tree(t₁,p₁)V^tree(t₂,p₂) Le pr´edicat de repr´esentation garantit que les deux sous-arbres sont disjoints, et peuvent donc ˆetre parcourus et modifi´es en parall`ele.

incrtree tδ = ift6=NULL then

letl=get(t)andn=get(t+1)andr=get(t+2)in set(t+₁,n+δ);

incrtree lδkincrtree rδ

Absence de courses critiques

On ajoute une r`egle `a la s´emantique par r´eductions qui signale une erreur pour toute situation de course :

(c₁kc₂)/h→err si Acc(c₁)∩Acc(c₂)6=∅

Acc(c)est l’ensemble des adresses m´emoires que la commandec peut lire ou ´ecrire `a la prochaine ´etape de r´eduction :

Acc(get(a)) =Acc(set(a,a⁰)) =Acc(free(a)) ={a} Acc(letx=c₁inc₂) =Acc(c₁)

Acc(c₁kc₂) =Acc(c₁)∪Acc(c₂)

Absence de courses critiques

On montre facilement que

c/h6→err ⇒ Acc(c)⊆Dom(h)

Par cons´equent, sic₁/h₁ 6→erretc₂/h₂6→erreth₁ ⊥h₂, Acc(c₁)∩Acc(c₂)⊆Dom(h₁)∩Dom(h₂) =∅

et donc(c₁kc₂)/(h₁]h₂)ne peut pas se r´eduire enerr`a cause d’une course critique.

Le r´esultat de correction s´emantique (`a la fin de ce cours) formalise cette analyse et montre que si{P}c{Q}_{, la} commandecs’ex´ecute sans courses critiques.

Parall ´elisme et partage de

ressources

L’ ´emergence de la logique de s ´eparation concurrente

O’Hearn, Reynolds, Yang (2001),Local Reasoning about Programs that Alter Data Structures. La pr´esentation moderne de la logique de s´eparation s´equentielle.

O’Hearn (2001–2002),Notes on separation logic for shared-variable concurrency, non publi´e.

Reynolds (2002),Separation Logic : A Logic for Shared Mutable Data Structures. Donne la r`egle de s´eparation pour le parall´elisme et mentionne les travaux en cours de O’Hearn.

O’Hearn (2004),Resources, Concurrency and Local Reasoning. Les id´ees cl´es + les principaux exemples.

Brookes (2004),A Semantics for Concurrent Separation Logic. Une s´emantique et une preuve de correction pour la logique de O’Hearn.

Les ressources partag ´ees

Une ressource se compose de

• une ou plusieurs cases m´emoire :

variables globales, objets allou´es dynamiquement ;

• un verrou (lock) ou autre dispositif d’exclusion mutuelle qui prot`ege les acc`es aux cases m´emoire.

Exemple (un compteur partag ´e) class Counter { int val; }

Exemple (une liste doublement chaˆın ´ee partag ´ee) class DList { DListCell first, last; }

class DListCell { Object data; DListCell prev, next; }

Ressources partag ´ees en logique de s ´eparation

Id´ee g´eniale de O’Hearn : une ressource partag´ee peut ˆetre d´ecrite par une assertionAde logique de s´eparation.

• L’empreinte m´emoire deAd´efinit l’ensemble des cases m´emoires appartenant `a la ressource.

• L’assertionAsp´ecifie aussi la structure de ces cases (liste doublement chaˆın´ee) et d’autres invariants.

Exemple (un compteur partag ´ep) p7→nVhn≥₀i

Exemple (une liste doublement chaˆın ´eep,q)

∃x,y,w, p7→xV^q7→yV^dlist(w,x,y)

Sections critiques en logique de s ´eparation

L’acc`es `a une ressource partag´eerse fait uniquement dans une section critique

withrdoc

en exclusion mutuelle avec les autres processus.

NotantRI_rl’assertion (l’invariant) associ´ee `a la ressourcer:

{RIr V^P}c{RIr V^Q} {P}withrdoc{Q}

`A l’entr´ee de la section critique, le processus acquiert la permission d’utiliser les cases m´emoire de la ressource, d´ecrites parRIr. Avant de sortir de la section critique, le processus doit r´etablir l’invariantRI car d’autres processus vont entrer en section critique.

Sections critiques conditionnelles en logique de s ´eparation

L’article original de O’Hearn consid`ere des sections critiques conditionnelles

withrwhenbdoc

o `ucest ex´ecut´e seulement lorsque la conditionbest vraie.

La r`egle pour les s.c.c. est :

{ hbiV^RIr V^P}c{RIr V^Q} {P}withrwhenbdoc{Q}

Exemple : d ´ecr ´ementer un compteur partag ´e

{emp} withrdo

{ ∃n, p7→nVhn≥₀i } letn=get(p)in

{p7→nVhn≥₀i } ifn>0then set(p,n−₁)

{ ∃n⁰, p7→n⁰ Vhn⁰ ≥₀i } done

{emp}

Exemple : insertion dans une liste partag ´ee

{emp} withrdo

{ ∃q,w, p7→qV^list(w,q)} letq=get(p)in

{p7→qV∃w, list(w,q)} leta=cons(x,q)in

{a7→xV^a+₁7→qV^p7→qV∃w, list(w,q)} set(p,a)

{p7→aV^a7→xV^a+₁7→qV∃w, list(w,q)}

⇒{ ∃q,w, p7→qV^list(w,q)} done

{emp}

Formalisation simplifi ´ee : les sections atomiques

Commandes : c::=. . .

|c₁kc₂ ex´ecutec₁etc₂en parall`ele

|atomicc ex´ecutecenune ´etape ins´ecable Une sectionsuper-critique: pendant l’ex´ecution deatomicc, tous les autres processus sont bloqu´es et n’ex´ecutent rien.

Pertinence pratique :

• Si on fait du temps partag´e sur un unique processeur : section atomique≈bloquer temporairement la pr´eemption.

• Mod´elise desinstructions atomiquesdu processeur.

Mod ´elisation des instructions atomiques des processeurs

´Echange atomique (swap) et ses cas particuliers :

swap(p,n)^def= atomic(letx=get(p)in set(p,n);x) test and set(p)^def= swap(p,1)

read and clear(p)^def= swap(p,0) Incr´ement / d´ecr´ement atomique :

fetch and add(p,d)^def= atomic(letx=get(p)in set(p,x+d);x) Comparaison et ´echange (compare and swap) :

CAS(p,x,n)^def= atomic(letc=get(p)in

ifc=xthen(set(p,n);1)else0)

S ´emantique op ´erationnelle des sections atomiques

(atomicc)/h→a/h⁰ sic/h→^∗ a/h⁰ (atomicc)/h→err _sic/h→^∗ err

Note :atomicc₁katomicc₂est donc ´equivalent `ac₁;c₂ouc₂;c₁. Il n’y a pas d’entrelacement entre les ´etapes de r´eduction dec₁et celles dec₂.

Note : sic/hdiverge,(atomicc)/hest bloqu´ee. En pratique,cne contient pas de boucles et termine toujours.

Un

triplet

pour le parall ´elisme `a sections critiques

J ` { P } c { Q }

L’assertionJest un invariant sur la m´emoire partag´ee

(accessible uniquement dans des sections atomiquesatomicc).

La pr´econditionPet la postconditionQd´ecrivent la m´emoire propre `a la commandec.

Les r `egles pour les sections atomiques

Ex´ecution d’une section atomique :

emp` {PV<sup>J</sup>}c{λv.Q v V<sup>J</sup>} J` {P}atomicc{Q}

Partage d’une ressourceJ⁰: Encadrement sur l’invariant :

JV^J0` {P}c{Q} J` {PV^J0}c{λv.Q vV^J0}

J` {P}c{Q} JV<sup>J0</sup>` {P}c{Q}

Les r `egles pour les structures de contrˆ ole (rappel)

P⇒Q[[a]]

J` {P}a{Q}

J` {P}c{R} ∀v, J` {R v}c⁰[x←v]{Q} J` {P}letx=cinc⁰{Q}

J` { hbiV<sup>P</sup>}c<sub>1</sub>{Q} J` { h¬biV^P}c₂{Q} {P}ifbthenc₁elsec₂{Q}

J` {P<sub>1</sub>}c<sub>1</sub>{λ .Q<sub>1</sub>} J` {P₂}c₂{λ .Q₂} J` {P₁V^P₂}c₁kc₂{λ .Q₁V^Q₂}

Les

petites

r `egles pour les acc `es m ´emoire (rappel)

J` {emp}alloc(N) {λ`. `7→ V· · ·V`+N−₁7→ } J` {[[a]]7→x} get(a) {λv.hv=xiV[[a]]7→x}

J` {[[a]]7→ }set(a,a<sup>0</sup>) {λv.[[a]]7→[[a<sup>0</sup>]]} J` {[[a]]7→ } free(a) {λv.emp}

Les r `egles structurelles (attention ! pi `ege !)

J` {P}c{Q}

(encadrement)

J` {PV^R}c{λv.Q v V^R}

P⇒P⁰ J` {P⁰}c{Q⁰} ∀v, Q⁰v⇒Q v

(cons´equence)

J` {P}c{Q}

J` {P}c{Q} J` {P⁰}c{Q⁰}

(disjonction)

J` {P∨P<sup>0</sup>}c{λv.Q v∨Q<sup>0</sup>v} Jpr´ecise J` {P}c{Q} J` {P⁰}c{Q⁰}

(conjonction)

J` {P∧P⁰}c{λv.Q v∧Q⁰ v}

La r `egle de conjonction et le contre-exemple de Reynolds

Soitone=₁7→ _{. On a}oneVtrue⇒true_{, donc} emp` {oneVtrue}<sub>0</sub>{λ .empVtrue} emp` {oneVtrue}₀{λ .oneVtrue} et en appliquant la r`egleatomic_,

J` {one}atomic0{λ .emp} J` {one}atomic0{λ .one}

Si la r`egle de conjonction ´etait vraie pour toutJ, on concluerait J` {one∧one}atomic₀{λ .emp∧one}

or la postconditionemp∧oneest toujours fausse.

Les assertions pr ´ecises

Intuitivement : une assertionPestpr´ecisesi son empreinte m´emoire est d´efinie de mani`ere unique.

Formellement : siPd´ecoupe un sous-tash₁dans un tashdonn´e, ce sous-tash₁est d´etermin´e de mani`ere unique :

h=h₁]h₂=h⁰₁]h⁰₂ ∧ P h₁ ∧ P h⁰₁ ⇒ h₁=h⁰₁

Exemples d’assertions pr ´ecises ou non

Assertions pr´ecises Assertions non pr´ecises

emp true

`7→ ∃`, `7→

`7→v ∃`, `7→v

∃v, `7→vV^R(v)

PV^{Q P}Vtrue

hbiV^P∨ h¬biV^Q emp∨`7→

(siP,Q,R(v)sont pr´ecises)

S ´emaphores binaires et applications

Codage des s ´emaphores binaires

Un s´emaphore binaire = une case m´emoirepqui contient 0 (signifiantnon disponible) ou 1 (signifiantdisponible).

Les op´erationsP(prendre) etV(relˆacher) : V(sem) =atomic(set(sem,1)) P(sem) =letx=swap(sem,0)in

ifx=1then0elseP(sem) avec

swap(p,n) =atomic(letx=get(p)in set(p,n);x)

Note :P(sem)fait une attente active, et peut ne pas terminer, mais la boucle est en dehors de la section atomique.

Les r `egles pour les s ´emaphores binaires

SoitRIl’assertion d´ecrivant les ressources associ´ees au s´emaphore. On suppose queRIest pr´ecise.

On prend comme invariant sur l’´etat partag´e

J(sem,RI) ^def= ∃n.sem7→nV(hn=0i ∨ hn=1iV^RI) c’est-`a-diresi le s´emaphore est occup´e, les ressourcesRIsont dans la m´emoire partag´ee. On peut alors d´eriver :

J(sem,RI)` {RI}V(sem){emp} J(sem,RI)` {emp}P(sem){RI}

Autrement dit : donnerpc’est placerRIdans la m´emoire partag´ee, et prendrepc’est r´ecup´ererRIdepuis la m´emoire partag´ee.

Synchronisation avec un s ´emaphore

On prend l’assertionRI=∃n,x7→nVhnpremieri_,

la variablexcontient un nombre premier. {sem7→₀V^x 7→ } {x7→ }

set(x,₅₃);

{x7→₅₃}⇒{RI} V(sem) {emp}

{emp} P(sem);

{RI}

letn=get(x)in

{x7→nVhnpremieri } print(n)

LePet leVassurent que le processus droit ne lit pasxavant que le processus gauche ne l’ait initialis´e, et transf`erent la permission d’acc´eder `axdu processus gauche au processus droit.

Synchronisation et transfer de ressources avec un s ´emaphore

la variablexpointe vers une adresse valide. {sem7→₀V^x 7→ } {x 7→ }

letp=alloc(1)in {x 7→ V^p7→ }

set(x,p);

{x 7→pV^p7→ }⇒{RI} V(sem)

{emp}

{emp} P(sem);

{RI}

letp=get(x)in {x7→pV^p7→ } free(p)

{x7→ }

La m´emoire allou´ee par le processus gauche est transf´er´ee et d´esallou´ee sans risques par le processus droit.

D ´erivation de la r `egle pour

On rappelle l’invariant sur l’´etat partag´e :

J(sem,RI) ^def= ∃n.sem7→nV(hn=₀i ∨ hn=₁iV^RI) Pourswap(sem,₀), on a le triplet

J(sem,RI)` {emp}swap(sem,0){λn.hn=0i ∨ hn=1iV<sup>RI</sup>} P(sem)it`ereswap(sem,0)jusqu’`a ce que le r´esultat soit 1, d’o `u

J(sem,RI)` {emp}P(sem){RI}

D ´erivation de la r `egle pour

J(sem,RI) ^def= ∃n.sem7→nV(hn=₀i ∨ hn=₁iV^RI) Il suffit de montrer

emp` {RIV<sup>J</sup>(sem,RI)}set(sem,<sub>1</sub>){sem7→<sub>1</sub>V<sup>RI</sup>} pour avoiremp` {RIV^J(sem,RI)}set(sem,₁){J(sem,RI)} et doncJ(sem,RI)` {RI}V(sem){emp}_.

Mais on ne connait pas l’´etat du s´emaphore (vide ou occup´e) : emp` {RIV<sup>sem</sup>7→<sub>0</sub>}set(sem,<sub>1</sub>){sem7→<sub>1</sub>V<sup>RI</sup>}<sub>(vide)</sub> emp` {RIV^sem7→₁V^RI}set(sem,₁){sem7→₁V^RI}_(occup´e) Dans le 2^ecas il fautRIV^RI⇒RI, qui est vrai siRIest pr´ecise.

Codage des sections critiques

On peut utiliser un s´emaphore comme un verrou : Pprend le verrou,Vle rend.

D’o `u un codage simple des sections critiques : withrdoc ^def= P(r);c;V(r)

o `u chaque section critiquerest identifi´ee par l’adresse m´emoire d’un s´emaphore, initialis´e `a 1.

Codage des sections critiques

SiRI_r est l’invariant de la ressourcer, l’invariant de m´emoire partag´ee s’obtient en prenant la conjonction des invariants des s´emaphores :

J_R = _r∈R

V

Ce codage valide la r`egle pour les sections critiques :

r∈ R J_R\{r} ` {RI_r V^P}c{RI_r V^Q}

J_R` {P}withrdoc{Q}

Codage des sections critiques conditionnelles

Dans notre langage PTR, la conditionc_bd’une s.c.c. est n´ecessairement une commande qui s’´evalue en un bool´een.

withrwhenc_bdoc ^def= P(r); wait(r,c_b); c; V(r) o `uwaitest la boucle suivante :

wait(r,c_b) = letb=c_bin

ifbthen0else(V(r); P(r); wait(r,c_b)) On d´erive la r`egle suivante :

r∈ R

J_R\{r}` {RIr V<sup>P</sup>}c<sub>b</sub>{λb.hbiV<sup>B</sup>∨ h¬biV<sup>RI</sup>r V<sup>P</sup>} J<sub>R\{r}</sub> ` {B}c{RI_r V^Q}

` { } { }

Le sch ´ema producteur/consommateur

Une g´en´eralisation de l’exemplesynchronisation et transfer de ressources, o `u plusieurs ressources sont transf´er´ees

successivement.

while true do calculerx; produce(x);

done

while true do

lety=consume()in utilisery

done

Les ressources produites mais pas encore consomm´ees sont stock´ees dans un tampon en m´emoire partag´ee.

Note : on peut avoir plusieurs processus producteurs et plusieurs processus consommateurs.

Une solution avec un tampon de taille 1 et deux s ´emaphores

Trois variables en m´emoire partag´ee :

• b: adresse du tampon (une case m´emoire)

• s₁: un s´emaphore qui est `a 1 lorsque le tampon est plein (contient une donn´ee produite pas encore consomm´ee).

• s₀ : un s´emaphore qui est `a 1 lorsque le tampon est vide (ne contient pas de donn´ee produite et pas encore consomm´ee)

Impl´ementation :

produce(b,s₀,s₁,x) = P(s₀); set(b,x); V(s₁)

consume(b,s₀,s₁) = P(s₁); letx=get(b)inV(s₀); x

Sp ´ecification et v ´erification du producteur/consommateur

J(b)` {RI(x)}produce(b,s<sub>0</sub>,s<sub>1</sub>,x){emp} J(b)` {emp}consume(b,s₀,s₁){λx.RI(x)}

La v´erificationpasseen prenant comme invariantJsur l’´etat partag´e

J(b) ^def= J(s₀,b7→ )V^J(s₁,∃x, b7→xV^RI(x)) En d’autres termes : quand le s´emaphores₀est `a 1,best valide (on peut ´ecrire dedans) ; quand le s´emaphores<sub>1</sub>est `a 1,

bcontient une donn´eexqui satisfaitRI(x).

Correction s ´emantique

Correction s ´emantique de la logique de s ´eparation concurrente

La d´emonstration originale de Brookes (2004) :

• S´emantique d´enotationnelle des commandes sous forme de traces d’actions.

• Une s´emantiquelocaledes actions et des traces qui met en

´evidence la possession des ressources et les transfers de ressources lors des sections critiques.

• Une hypoth`ese : tous les invariants de ressource sont pr´ecis.

La d´emonstration simplifi´ee de Vafeiadis (2011) :

• Raisonnement direct et ´el´ementaire sur les suites de r´eductions,

`a l’aide d’un pr´edicat compt´eSafeⁿc h.

• Seule la r`egle de conjonction exige des invariants pr´ecis.

Quelques intuitions

J ` { P } c { Q }

Intuition d´eductive : c’est comme{PV^J}c{QV^J}

avec en plusJinvariant, c.`a.d. tous les triplets apparaissant dans la d´erivation sont de cette forme.

Intuition op´erationnelle : `a chaque ´etape de calcul, l’´etat m´emoire couranthse d´ecompose en trois parties disjointes :

h=h₁]h_j]h_f h₁est la m´emoire propre `ac.

h_jest la m´emoire partag´ee accessible aux sections atomiques.

h_f est la m´emoireencadrante, incluant les m´emoires propres des processus s’ex´ecutant en parall`ele avecc.

Un triplet s ´emantique faible avec comptage de pas

On d´efinit le triplet s´emantiqueJ|={{P}}c{{Q}}_: J|={{P}}c{{Q}} ^def= ∀n,h, P h⇒Safeⁿc h Q J Le pr´edicat inductifSafeⁿc h Q Jsignifie que les ex´ecutions dec dans la m´emoire propreh

– ne font pas d’erreur dans lesnpremi`eres ´etapes d’ex´ecution ; – satisfontQsi elles terminent en au plusn ´etapes ;

– pr´eservent l’invariantJsur la m´emoire partag´ee.

Safe⁰c h Q J

Q[[a]]h Safeⁿ⁺¹a h Q J

(∀a,c6=a) · · · Safeⁿ⁺¹c h Q J

Un triplet s ´emantique faible avec comptage de pas

∀a,c6=a

∀h_j,h_f, J h_j⇒c/h₁]h_j]h_f 6→err

∀h_j,h_f,c⁰,h⁰, J h_j∧c/h₁]h_j]h_f →c⁰/h⁰ ⇒

∃h⁰₁,h⁰_j, h⁰ =h⁰₁]h⁰_j]h_f∧J h⁰_j∧Safeⁿc⁰h⁰₁Q Safeⁿ⁺¹c h₁Q

Le cas r´ecursif :cdansh₁est sˆure pourn+1 ´etapes si

• dans tout ´etathde la formeh₁]h_j]h_f avech_jsatisfaisantJ, c/hne fait pas d’erreurs, et . . .

• pour toute r´eductionc/h→c⁰/h⁰, l’´etath⁰se d´ecompose en h⁰₁]h⁰_j]h_f avech⁰_jsatisfaisantJ,

et de plusc⁰dansh⁰₁est sˆure pourn ´etapes.

Un triplet s ´emantique faible avec comptage de pas

∀a,c6=a

∀h_j,h_f, J h_j⇒c/h₁]h_j]h_f 6→err

∀h_j,h_f,c⁰,h⁰, J h_j∧c/h₁]h_j]h_f →c⁰/h⁰ ⇒

∃h⁰₁,h⁰_j, h⁰ =h⁰₁]h⁰_j]h_f∧J h⁰_j∧Safeⁿc⁰h⁰₁Q Safeⁿ⁺¹c h₁Q

Le cas r´ecursif :cdansh₁est sˆure pourn+1 ´etapes si

• dans tout ´etathde la formeh₁]h_j]h_f avech_jsatisfaisantJ, c/hne fait pas d’erreurs, et . . .

• pour toute r´eductionc/h→c⁰/h⁰, l’´etath⁰se d´ecompose en h⁰₁]h⁰_j]h_f avech⁰_jsatisfaisantJ,

et de plusc⁰dansh⁰₁est sˆure pourn ´etapes.

Un triplet s ´emantique faible avec comptage de pas

∀a,c6=a

∀h_j,h_f, J h_j⇒c/h₁]h_j]h_f 6→err

∀h_j,h_f,c⁰,h⁰, J h_j∧c/h₁]h_j]h_f →c⁰/h⁰ ⇒

∃h⁰₁,h⁰_j, h⁰ =h⁰₁]h⁰_j]h_f∧J h⁰_j∧Safeⁿc⁰h⁰₁Q Safeⁿ⁺¹c h₁Q

Le cas r´ecursif :cdansh₁est sˆure pourn+1 ´etapes si

• dans tout ´etathde la formeh₁]h_j]h_f avech_jsatisfaisantJ, c/hne fait pas d’erreurs, et . . .

• pour toute r´eductionc/h→c⁰/h⁰, l’´etath⁰se d´ecompose en h⁰₁]h⁰_j]h_f avech⁰_jsatisfaisantJ,

et de plusc⁰dansh⁰₁est sˆure pourn ´etapes.

Correction s ´emantique et d ´ecompositions de l’ ´etat m ´emoire

On montre sans trop de peine que ce triplet s´emantique

J|={{P}}c{{Q}}satisfait les r`egles de la logique de s´eparation concurrente.

Voici une illustration de la d´ecompositionh=h₁]h_j]hf `a utiliser pour chacune des principales r`egles :

emp` {PV<sup>J</sup>}c{QV<sup>J</sup>} J` {P}atomicc{Q}

(h₁]h_j) ] ∅ ] h_f h₁ ] h_j ] h_f JV^J0 ` {P}c{Q}

J` {PV^J0}c{λv.Q vV^J0}

h₁ ] (h_j]h₂) ] h_f (h₁]h₂) ] h_j ] h_f

Correction s ´emantique et d ´ecompositions de l’ ´etat m ´emoire

J` {P<sub>1</sub>}c<sub>1</sub>{λ .Q<sub>1</sub>} J` {P₂}c₂{λ .Q₂} J` {P₁V^P2}c₁kc₂{λ .Q₁V^Q2}

h₁ ] h_j ] (h_f ]h₂) ou h₂ ] h_j ] (h_f ]h₁) (h₁]h₂) ] h_j ] h_f

J` {P}c{Q} JV<sup>J0</sup>` {P}c{Q}

h₁ ] h_j ] (h_f ]h⁰_j) h₁ ] (h_j]h⁰_j) ] h_f

J` {P}c{Q} J` {PV^R}c{λv.Q vV^R}

h₁ ] h_j ] (h_f]h₂) (h₁]h₂) ] h_j ] h_f

Absence de courses critiques

(c₁kc₂)/h→err _si Acc(c₁)∩Acc(c₂)6=∅ Si on ajoute la r`egle d’erreur ci-dessus et que l’on prend

Acc(atomicc) =∅,

la d´emonstration de correction s´emantiquepasseencore, ce qui montre :

Toute commande c prouvable en logique de s ´eparation concurrente ne contient aucune course critique

entre acc `es m ´emoire non atomiques.

Note :atomic(set(p,₁))katomic(set(p,₂))est prouvable mais n’est pas consid´er´e comme une course critique.

Point d’ ´etape

Point d’ ´etape

Apr`es l’´eclair de la logique de s´eparation (2001), le coup de tonnerre de la logique de s´eparation concurrente (2004).

Par rapport aux logiques pr´ec´edentes (p.ex. Owiki & Gries, 1976), un ´enorme progr`es pour montrer des propri´et´es de sˆuret´e des calculs parall`eles :

• absence de courses critiques ;

• sˆuret´e de la m´emoire ;(pas d’acc`es apr`esfree, pas de doublefree₎

• int´egrit´e des structures de donn´ees ;

• Transfers de donn´ees entre processus.

Encore du progr`es `a faire sur la correction fonctionnelle, p.ex.

{x=0}atomic(x:=x+1)katomic(x:=x+1){x=2}

Bibliographie

Bibliographie

Un livre de r´ef´erence sur le parall´elisme `a m´emoire partag´ee :

• M. Herlihy, N. Shavit.The Art of Multiprocessor Programming, Morgan Kaufman, 2012.

L’article fondateur de la logique de s´eparation concurrente (version r´evis´ee) :

• P. O’Hearn,Resources, Concurrency and Local Reasoning, Theor. Comp. Sci, 2007.

La d´emonstration simple de la correction s´emantique :

• V. Vafeiadis,Concurrent separation logic and operational semantics, MFPS 2011

M´ecanisations :

• Le d´eveloppement Coq correspondant `a ce cours :

https://github.com/xavierleroy/cdf-program-logics

• L’infrastructure Iris :