©andré santos, 2000 concorrência e sincronização andré santos cin-ufpe concorrência

©André Santos, 2000

Concorrência e Sincronização

André Santos

CIn-UFPE

Concorrência


Notação: Declarações

type days = (SUN,MON,...,SAT) var i : int := 0, x : real, s : string(10)

var forks[1:5]:bool := ([5] false) type student = rec (name:string(30) age : int classes[1:5] : string(15))


Notação: Statements

skip vector[1] := n + 2 v1 :=: v2 x := x+1; y := y-1 if B1 -> S1[] ...[] Bn -> Snfi



do B1 -> S1[] ...[] Bn -> Snod

MDC:x := X; y := Ydo x > y -> x := x – y[] y > x -> y := y – xod



fa i:=1 to n -> vector[i]:=0 af

procedure inc (var x:int) x := x + 1end


Notação: Concorrência

co S1 // ... // Sn oc x := 0; y := 0co x:= x + 1 // y:= y + 1 ocz := x + y

co i := 1 to n -> a[i]:=0 oc



var a[1:n], b[1:n] : intLargest:: var max:int max:=a[1] fa j:=2 to n st max < a[j]

-> max := a[j] af



Sum[i:1..n]:: b[i] := a[1] fa j:=2 to i -> b[i] := b[i] + a[j] af


Políticas de Escalonamento e Fairness Várias das propriedades de liveness

dependem de fairness. O escalonamento se preocupa em como

garantir que processos tenham chance de prosseguir, independentemente das ações dos demais processos. A existência de várias ações elegíveis fazem com

que uma política de escalonamento seja usada para definir qual será executada.


Atomicidade de fina granularidade Ação atômica faz uma transformação

indivisível no estado. Qualquer estado intermediário na

implementação da ação deve ser invisível para os outros processos.

Ação atômica de fina granularidade é implementada diretamente pelo hardware em que o programa concorrente executa.


Exemplo: atribuição

y:=0; z:=0co x := y+z // y :=1; z:=2 oc

x = 0,1,2 ou 3?


Assumir nos exemplos

Valores de tipos básicos são lidos e escritos como uma ação atômica

Valores são manipulados carregando-os em registros, executando operações e depois guardando os resultados na memória.

Cada processo tem seu conjunto de registros (chaveamento de contexto)

Resultados intermediários são guardados em registros ou em memória.


Especificando sincronização

Objetivo: possibilitar criação de ações atômicas de maior granularidade.

Exemplo: modificação simultânea em um banco de dados

<expressão> <await B -> S> <await (s>0) -> s := s-1>


Especificando sincronização

Exclusão mútua <x := x+1; y := y+1> Sincronização de condição <await count > 0> Ação atômica incondicional x

condicional


Políticas de Escalonamento e Fairness Exemplo:var continue := trueLoop:: do continue -> skip odStop:: continue := False

O que acontece se o escalonador faz o chaveamento de contexto (context switch) apenas quando um processo termina ou fica em espera?


Unconditional Fairness

Uma política de escalonamento é incondicionalmente justa se toda ação atômica incondicional que é elegível é executada em algum momento.

Para o exemplo anterior, round-robin ou execução paralela em multiprocessadores seria incondicionalmente justa.


Weak Fairness

Na presença de ações atômicas condicionais, é necessário hipóteses mais fortes para garantir que os processos vão progredir.

Uma política de escalonamento é fracamente justa se ela é incondicionalmente justa e toda ação atômica condicional elegível é executada em algum momento, assumindo que sua guarda se torne verdadeira e não seja subsequentemente mudada para falso por outro processo.


Weak Fairness

Round-robin e timeslicing são fracamente justas.

O processo em algum momento verá que sua condição de espera se tornou verdadeira.


Strong Fairness

Se a guarda pode mudar - de falsa para verdadeira e novamente para falsa – enquanto um processo espera.

Uma política de escalonamento é fortemente justa se ela é incondicionalmente justa e toda ação atômica condicional elegível é executada em algum momento, assumindo que a guarda é infinitamente frequentemente verdadeira.


Strong Fairness

Exemplo:var continue := true, try := false;Loop:: do continue -> try := true; try := false odStop:: <await try -> continue := false>


Strong Fairness

De forma geral não é viável na prática: Alternar a cada instrução Escalonador de um multiprocessador

Não é fortemente justo: Round-robin e timeslicing


Strong Fairness

Instâncias específicas:<await (s > 0) -> s := s - 1>

2 processos de espera, demais incrementam s

Escalonador FCFS (First Come First Served)

©andré santos, 2000 concorrência e sincronização andré santos cin-ufpe concorrência

Documents