©André Santos, Concorrência: Sincronização de fina granularidade II André Santos CIn-UFPE

©André Santos, Algorítmo do Tie Breaker n Permite implementar exclusão mútua sem suporte de instruções especiais do processador (Test-and-set, exchange etc.). n Garante entrada eventual dos processos na região crítica mesmo com escalonamento weakly-fair n Também chamado de algorítmo de Peterson

©André Santos, Solução de granularidade grossa n int In1=FALSE, In2 = FALSE, last = 1; void P1 () { void P2 () { while (TRUE) while (TRUE) { Non_Cr_S_1; { Non_Cr_S_2; In1=TRUE;last=1; In2=TRUE; last=2; last==1)> Crit_S_1; Crit_S_2; In1 = FALSE; In2 = FALSE; } } } }

©André Santos, Solução de granularidade fina n int In1=FALSE, In2 = FALSE, last = 1; void P1 () { void P2 () { while (TRUE) while (TRUE) { Non_Cr_S_1; { Non_Cr_S_2; In1=TRUE;last=1; In2=TRUE; last=2; while while (In2 && last==1) (In1 && last==2) {}; {}; Crit_S_1; Crit_S_2; In1 = FALSE; In2 = FALSE; } } } }

©André Santos, Algorítmo do Tie Breaker n Para n processos se torna complexo e pouco eficiente n precisa de um loop de n-1 estágios, cada estágio com uma instância da versão para 2 processos. n Complexidade O(n²) ou O(n*m), onde m é o número de processos querendo entrar na região crítica em um dado instante.

©André Santos, Solução para n processos n void Pi () { while (TRUE) { Non_Cr_S_1; for (j=1;j =in[i] && last[j]=i) {}}; }; }; Crit_S_1; In[i] = 0; }}

©André Santos, Algorítmo do Ticket n Funciona como lojas em que se pega um ticket para esperar sua vez. n Fácil de estender para n processos.

©André Santos, Solução de granularidade grossa n int number = 1; next = 1,int turn[n] = 0; void Pi () { while (TRUE) { Non_Cr_S_1; ; ; Crit_S_1; ; } }

©André Santos, Solução de granularidade fina n int number = 1; next = 1,int turn[n] = 0; void Pi () { while (TRUE) { Non_Cr_S_1; turn[i] = FetchAndAdd(number,1) while (turn[i] != next) {}; Crit_S_1; next ++; /* need not be atomic */ } }

©André Santos, Algorítmo do Ticket n A variável number pode ser resetada depois que se tornar grande. n Se uma instrução de FetchAndAdd não estiver disponível, poderia ser usado algum dos outros algorítmos para implementar a atomicidade desta instrução.

©André Santos, Algorítmo da Padaria n Semelhante ao do ticket, mas não depende de instruções especiais n Mais complexo n Cada processo pega para si um ticket que é maior que os dos demais processos e espera até que o dele seja o menor de todos os tickets. n A verificação não é centralizada

©André Santos, Solução de granularidade grossa n int turn[n] = 0; void Pi () { while (TRUE) { ; for (j=1;j }; } Crit_S_1; ; Non_Cr_S_1; } }

©André Santos, Tentativa 1 de granularidade fina n int turn1 = 0; int turn2 = 0; void P1 () { while (TRUE) {turn1 =turn2 + 1; while (turn2 != 0 && turn1 > turn2) {}; Crit_S_1; turn1 = 0; Non_Cr_S_1; } } void P2 () { while (TRUE) {turn2 = turn1 + 1; while (turn1 != 0 && turn2 > turn1) {}; Crit_S_2; turn2 = 0; Non_Cr_S_2; } }

©André Santos, Tentativa de granularidade fina 2 n int turn1 = 0; int turn2 = 0; void P1 () { while (TRUE) {turn1 =turn2 + 1; while (turn2 != 0 && turn1 > turn2) {}; Crit_S_1; turn1 = 0; Non_Cr_S_1; } } void P2 () { while (TRUE) {turn2 = turn1 + 1; while (turn1 != 0 && turn2 >= turn1) {}; Crit_S_2; turn2 = 0; Non_Cr_S_2; } }

©André Santos, Solução de granularidade fina n int turn1 = 0; int turn2 = 0; void P1 () { while (TRUE) {turn1 = 1; turn1 =turn2 + 1; while (turn2 != 0 && turn1 > turn2) {}; Crit_S_1; turn1 = 0; Non_Cr_S_1; } } void P2 () { while (TRUE) {turn2 = 1; turn2 = turn1 + 1; while (turn1 != 0 && turn2 >= turn1) {}; Crit_S_2; turn2 = 0; Non_Cr_S_2; } }

©André Santos, Solução de granularidade fina n int turn[n] = 0; void Pi () { while (TRUE) {turn[i] = 1; turn[i] = max(turn) + 1; for (j=1;j (turn[j],j)) {}; } Crit_S_1; turn[i] = 0; Non_Cr_S_1; } }

©André Santos, Sincronização em Barreira n Usada em algorítmos paralelos iterativos n Custo de criação de processos x custo de sincronização: mais barato sincronizar do que criar processos com freqüência

©André Santos, Sincronização em Barreira n Usada em algorítmos paralelos iterativos n Custo de criação de processos x custo de sincronização: mais barato sincronizar do que criar processos com freqüência

©André Santos, Ineficiente n void Main () { while (TRUE) { co i := 1 to n -> código para implementar tarefa i; }

©André Santos, Sincronização em barreira n void Pi () { while (TRUE) { código para implementar tarefa i; espera todas as n tarefas completarem; }

©André Santos, Sol.1: Contador compartilhado n int count = 0; BOOL passed[n] = FALSE; void Pi () { while (TRUE) { código para implementar tarefa i; ; passed[i] = TRUE>; }

©André Santos, Sol.1: Contador compartilhado n Dificuldades:  Incremento tem que ser atômico  Como resetar o contador?  Acesso de todos os processos à variável do contador

©André Santos, Sol.2: Bandeiras e coordenadores n void Pi () { while (TRUE) { código para implementar tarefa i; arrive[i] = 1; ; continue[i] = 0; }

©André Santos, Sol.2: Bandeiras e coordenadores n void Coordinator () { while (TRUE) { for (i=1;i ; arrive[i] = 0}; for (i=1;i<=n;i++) { continue[i] = 1}; }

©André Santos, Sol.2: Bandeiras e coordenadores n Desvantagens:  Um processo a mais  Espera proporcional ao número de processos

©André Santos, Sol.2: Bandeiras e coordenadores n Solução: Workers também funcionando como coordenadores: Combining Tree Barrier Worker... Worker... Worker

©André Santos, Princípios de sincronização de flags n O processo que espera por uma flag deve ser o mesmo que a resseta n Uma flag não deve ser setada até que se saiba que ela está ressetada.

©André Santos, Data Parallel Algorithms n Algorítmo iterativo que manipula um array compartilhado de forma repetitiva e em paralelo n Usados em multiprocessadores síncronos SIMD n MIMD = Multiple Instruction Multiple Data SIMD = Single Instruction Multiple Data

©André Santos, Parallel Prefix computations n Usados em vários algorítmos de processamento de imagem, processamento de matrizes etc. n Exemplo: cálculo da soma de um array em log 2 n passos: n valores iniciais: [1,2,3, 4, 5, 6] soma com distância 1: [1,3,5, 7, 9,11] soma com distância 2: [1,3,6,10,14,18] soma com distância 4: [1,3,6,10,15,21]

©André Santos, Algorítmo n int a[n]; int sum[n]; int old[n]; void Sumi () { d = 1; sum[i] = a[i]; /* inicializacao da soma */ barrier while (d = 1) {sum[i] = old[i – d] + sum[i];}; barrier d = 2 * d; } }

©André Santos, Implementação de processos n Kernel – estruturas de dados e rotinas internas do Sistema Operacional ou sistema de execução da linguagem n Objetivo: criar processadores virtuais que criam a ilusão de que o processo está executando em seu próprio processador

©André Santos, Implementação de processos n Precisamos implementar:  a criação e início de execução de processos  como parar um processo  como determinar que o processo ou um grupo de processos terminou n Primitivas: rotinas implementadas pelo kernel de forma que pareça ser atômica  fork - para criar processos  quit - para terminar processos

©André Santos, Implementação de processos n fork – cria um outro processo, que já pode entrar em execução, indica onde o processo começa e seus dados. n quit – termina um processo

©André Santos, Kernel para um processador n Todo kernel possui estruturas de dados para representar processos e três tipos de rotinas  Interrupt handlers  Primitivas  Dispatcher (escalonador)

©André Santos, Kernel para um processador n Um kernel pode ser organizado:  de forma monolítica – cada primitiva executa de forma atômica  Coleção de processos especializados que interagem para implementar as primitivas: I/O, memória etc.  Como um programa concorrente em que mais de um processo do usuário pode estar executando uma primitiva ao mesmo tempo

©André Santos, Descritor do processo n Estrutura de dados com:  Próxima instrução a ser executada  Conteúdo dos registradores do processador n Está atualizada sempre que o processo está idle (ocioso)

©André Santos, Execução de instruções do kernel n Iniciada por uma interrupção n Dois tipos:  Externas, de dispositivos  Internas (traps), do processo em execução. n Ao interromper um processo, o processador guarda informações sobre o estado do processo (para que possa continuar) e executa o interrupt handler correspondente

©André Santos, Execução de instruções do kernel n Processo executa uma SVC (supervisor call) para invocar uma interrupção. n O interrupt handler:  Inibe outras interrupções  Salva estado do processo  Chama primitiva  Chama o escalonador  Habilita novas interrupções  Um (outro) processo é executado

©André Santos, Execução de instruções do kernel n Listas de descritores de processos:  free list – descritores livres  ready list – processos prontos para executar  executing – indica o processo que está executando

©André Santos, Garantindo Justiça (fairness) n Uso de interval timer e de FIFO no escalonamento dos processos

©André Santos, Kernel para multiprocessadores n Semelhante, exceto pelo dispatcher n Como fazer melhor uso dos processadores:  Cada processador ocioso fica verificando periodicamente a ready list  Ao executar um fork procurar um processador ocioso  Ter um processo separado para o dispatcher, que procura processos para processadores ociosos