Alexandro Baldassin Programação Concorrente 2sem, 2017

Transcrição

1 Alexandro Baldassin Programação Concorrente 2sem, 2017

2 2 Programação concorrente Desempenho Lock global Complexidade

3 3 Programação concorrente Lock-free Desempenho Locks finos Lock global Complexidade

4 4 Programação concorrente HTM Lock-free Desempenho STM TM Locks finos Lock global Complexidade

5 5 Memória Transacional (TM) No modelo transacional, programadores usam o conceito de transação como abstração Atomicidade Consistência Isolamento Vantagens Nível de abstração maior Potencial ganho de desempenho Dependente de implementação (visto mais adiante) Composição de código

6 6 Memória Transacional (TM) No modelo transacional, programadores usam o conceito de transação como abstração Atomicidade Consistência Isolamento Vantagens Nível de abstração maior Potencial ganho de desempenho Dependente de implementação (visto mais adiante) Composição de código Detalhes de como realizar a sincronização são movidos do programador para o sistema de execução

7 7 Blocos atômicos O termo bloco atômico geralmente é usado quando o enfoque é sobre o suporte em linguagens Memória transacional (TM) é uma forma de se implementar blocos atômicos Nomenclatura ainda não consolidada!

8 8 Programando com blocos atômicos Programador delimita a região que deve ser executada atomicamente Exemplo com lista ligada Sistema de execução (pode ser hardware ou software) cuida de garantir atomicidade, isolamento e consistência public boolean add(int item) { Node pred, curr; boolean valid = false; atomic { pred = head; curr = pred.next; while (curr.key < item) { pred = curr; curr = curr.next; if (item!= curr.key) { Node node = new Node(item); node.next = curr; pred.next = node; valid = true; if (valid) return true; return false;

9 9 Suporte transacional no GCC 4.7 Suporte experimental a TM existe no GCC a partir da versão 4.7 (abril de 2012) As construções adicionadas à linguagem são baseadas no documento Draft Specification of Transactional Language Constructs for C++, versão The support is experimental. In particular, this also means that several parts of the implementation are not yet optimized. If you observe performance that is lower than expected, you should not assume that transactional memory is inherently slow; instead, please just file a bug.

10 10 Construções GCC Principais construções transaction_atomic { transaction_relaxed { transaction_cancel Anotações attribute ((transaction_safe)) attribute ((transaction_callable)) attribute ((transaction_pure)) Opção -fgnu-tm deve ser passada ao compilador

11 11 Exemplo com GCC lista ligada int list_add(list_node_t *head, int item) { list_node_t *pred, *curr; transaction_atomic { pred = head; curr = head->next; while (curr->key < item) { pred = curr; curr = curr->next; list_node_t *node = (list_node_t *)malloc(sizeof(list_node_t)); node->key = item; node->next = curr; pred->next = node; return 1; Demais operações implementadas da mesma forma

12 12 Detalhes da geração e execução O compilador gera duas versões para cada rotina especificada com o atributo transaction_safe A versão transacional é usada quando a rotina é chamada dentro de uma transação O código gerado é linkado com uma biblioteca de runtime chamada libitm Essa biblioteca pode ser substituída em tempo de execução Permite que diferentes implementações possam ser avaliadas de forma simples Especificação segue basicamente a ABI proposta pela Intel Intel Transactional Memory Compiler and Runtime Application Binary Interface, revisão 1.1 maio de 2009

13 13 Teste de stress da lista void *list_exercise(void *arg) { int operations = (int)arg; Todas as threads executam a mesma rotina int add_or_remove, chance, value, last_value = 0; add_or_remove = 1; /* 1 - add, 0 - remove */ while (operations--) { chance = (int)(erand48(seed)*100); value = (int)(erand48(seed)*range*2); if (chance <= UPD_RATE) { if (add_or_remove) { list_add(linked_list, value); last_value = value; else list_remove(linked_list, last_value); add_or_remove ^= 1; else list_contain(linked_list, value);

14 14 Alguns resultados Máquina: Intel(R) Core(TM) i7-2600k [3.4GHz, 8GB RAM] Tamanho do conjunto: elementos Número total de operações:

15 15 Taxa de atualização de 20% 80! 0" 0.1" 0.2" 0.3" 0.4" 0.5" 0.6" 0.7" 0.8" 0.9" 1" 70! 60! Tempo (s)! 50! 40! 30! 20! 1! 2! 3! 4! 5! 6! 7! 8! Número de threads! bloqueio global! bloqueio fino! GCC-STM! Sequencial!

16 16 Taxa de atualização de 50% 80! 0" 0.1" 0.2" 0.3" 0.4" 0.5" 0.6" 0.7" 0.8" 0.9" 1" 70! 60! Tempo (s)! 50! 40! 30! 20! 1! 2! 3! 4! 5! 6! 7! 8! Número de threads! bloqueio global! bloqueio fino! GCC-STM! Sequencial!

17 17 Até o momento Vimos como usar mutexes para prover acesso exclusivo a variáveis compartilhadas (seção crítica) Não vimos situações onde uma thread pode necessitar esperar por uma outra thread (ordem importa!) Em especial, uma thread pode ter sua execução condicionada a um evento realizado por outra thread Exemplo: Duas threads, T1 e T2, estão executando. Por alguma restrição do sistema, T2 só pode prosseguir/terminar DEPOIS que T1 já tiver realizado alguma ação crítica

18 18 Exemplo void * Thread1(void *arg) { /* ação crítica */ // como indicar que ação crítica foi executada? return NULL; void * Thread2(void *arg) { // como esperar pela ação crítica de Thread1? return NULL;

19 19 Solução 1 Busy waiting volatile int done = 0; void * Thread1(void *arg) { /* ação crítica */ done = 1; return NULL; void * Thread2(void *arg) { while (done == 0); return NULL; Funciona?

20 20 Problemas com busy waiting Processador fica ocupado sem fazer nada Dependendo do modelo de consistência de memória o programador deve adicionar instruções extras para forçar a ordem dos load/stores na memória Qual seria a solução ideal para este problema? Colocar a thread para dormir até que a condição se torne verdadeira Possível usar mutexes?

21 21 Solução com mutex? void * Thread1(void *arg) { pthread_mutex_lock(lock); /* ação crítica */ pthread_mutex_unlock(lock); return NULL; void * Thread2(void *arg) { pthread_mutex_lock(lock); pthread_mutex_unlock(lock); return NULL; Funciona?

22 22 Condition variables Para esperar até que uma condição se torne verdadeira, uma thread pode fazer uso de variáveis de condição Uma variável de condição é uma fila na qual as threads podem dormir enquanto alguma condição ainda não estiver satisfeita Quando a condição for satisfeita por alguma outra thread, ela acorda uma (ou mais) thread(s) esperando na fila da condição Duas operações básicas são fornecidas Wait Signal

23 23 Solução com condition variable condicao_critica void * Thread1(void *arg) { /* ação crítica */ signal(condicao_critica); return NULL; void * Thread2(void *arg) { wait(condicao_critica) return NULL; Funciona?

24 24 Solução com condition variable int done = 0; condicao_critica void * Thread1(void *arg) { /* ação crítica */ done = 1; signal(condicao_critica); return NULL; void * Thread2(void *arg) { if (done == 0) wait(condicao_critica) return NULL; Funciona?

25 25 Condition variables e Pthreads A operação wait necessita que um lock tenha sido adquirido antes de ser invocada int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); A operação signal geralmente deve ser invocada somente quando o mesmo lock (usado com wait) estiver sido adquirido int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond);

26 26 Operações WAIT e SIGNAL A operação WAIT internamente trata de liberar o lock associado antes de colocar a thread para dormir WAIT(CV,L) UNLOCK(L) SLEEP() LOCK(L) Existem duas semânticas para SIGNAL em termos de garantia Hoare SIGNAL acorda a thread e a coloca para execução imediatamente (colocando a thread que sinalizou para dormir) Mesa SIGNAL apenas acorda uma thread e a coloca na fila de threads prontas para execução Pthreads!

27 27 Nova versão da solução int done = 0; pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t c = PTHREAD_COND_INITIALIZER; void * Thread1(void *arg) { /* ação crítica */ pthread_mutex_lock(&m); done = 1; pthread_cond_signal(&c); pthread_mutex_unlock(&m); return NULL; void * Thread2(void *arg) { pthread_mutex_lock(&m); if (done == 0) pthread_cond_wait(&c, &m); pthread_mutex_unlock(&m) return NULL; Para esse exemplo é suficiente usar IF, mas para o caso geral é recommendável usar WHILE (mais detalhes adiante)

28 28 Problema do produtor/consumidor Existem dois tipos de threads executando concorrentemente no sistema Produtora Produz um determinado item e o coloca em um buffer compartilhado Consumidora Retira o item do buffer compartilhado e o utiliza de alguma forma Como o buffer é limitado em termos de tamanho, um produtor não pode adicionar um item se o mesmo já estiver cheio Deve esperar por algum item ser consumido Da mesma forma, um consumidor não pode consumir um item se o buffer estiver vazio Deve esperar por algum item ser produzido

29 29 Um buffer simples static int buffer; static int size = 0; int buffer_is_empty() { return size == 0; int buffer_is_full() { return size == 1; void buffer_put (int value) { assert(size == 0); size = 1; buffer = value; int buffer_get() { assert(size == 1); size = 0; return buffer;

30 30 Programa teste /* producer thread */ void *producer(void *arg) { long int i; long int loops = (long int)arg; for (i=0; i<loops; i++) buffer_put(i); /* consumer thread */ void *consumer(void *arg) { int i; for (i=0; i<loops; i++) { int tmp = buffer_get(); fprintf(stdout, "%d\n", tmp); Aplicação teste disponibilizada dispara um certo número de threads produtoras e consumidoras, as quais produzem e consomem uma certa quantidade de itens. Parâmetros: <#producers> <#consumers> <#items> Deve ser múltiplo de #producers e #consumers

31 31 Primeira versão /* producer thread */ void *producer(void *arg) { long int i; long int loops = (long int)arg; for (i=0; i<loops; i++) { pthread_mutex_lock(&mutex); if (buffer_is_full()) pthread_cond_wait(&cond, &mutex); buffer_put(i); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); /* consumer thread */ void *consumer(void *arg) { long int i; long int loops = (long int)arg; for (i=0; i<loops; i++) { pthread_mutex_lock(&mutex); if (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); fprintf(stdout, "%d\n", tmp);

32 32 Qual o problema? Lembre-se da semântica Mesa! Imagine 1 produtor e 2 consumidores e buffer == empty cond pthread_mutex_lock(&mutex); if (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); Consumidor 1 int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex);

33 33 Qual o problema? Lembre-se da semântica Mesa! Imagine 1 produtor e 2 consumidores e buffer == empty C1 cond Produtor 1 pthread_mutex_lock(&mutex); if (buffer_is_full()) pthread_cond_wait(&cond, &mutex); buffer_put(i); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex);

34 34 Qual o problema? Lembre-se da semântica Mesa! Imagine 1 produtor e 2 consumidores e buffer == empty C1 cond C1 é acordado (colocado na fila de processos READY) mas, antes que consiga continuar, um outro, C2, é executado pthread_mutex_lock(&mutex); if (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex);

35 35 Qual o problema? Lembre-se da semântica Mesa! Imagine 1 produtor e 2 consumidores e buffer == empty cond C2 adquire o lock e tira o elemento do buffer pthread_mutex_lock(&mutex); if (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex);

36 36 Qual o problema? Lembre-se da semântica Mesa! Imagine 1 produtor e 2 consumidores e buffer == empty cond Quando C1 volta a executar, ele tenta consumir um elemento que não existe! pthread_mutex_lock(&mutex); if (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex);

37 37 Qual o problema? Lembre-se da semântica Mesa! A condição testada deve ser colocada dentro de um laço do tipo WHILE

38 38 Segunda versão /* producer thread */ void *producer(void *arg) { long int i; long int loops = (long int)arg; for (i=0; i<loops; i++) { pthread_mutex_lock(&mutex); while (buffer_is_full()) pthread_cond_wait(&cond, &mutex); buffer_put(i); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); /* consumer thread */ void *consumer(void *arg) { long int i; long int loops = (long int)arg; for (i=0; i<loops; i++) { pthread_mutex_lock(&mutex); while (buffer_is_empty()) pthread_cond_wait(&cond, &mutex); int tmp = buffer_get(); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); fprintf(stdout, "%d\n", tmp);

39 39 Qual o problema? Imagine 2 produtores e 2 consumidores e buffer == empty C1 C2 cond Os dois consumidores ficam aguardando na fila

40 40 Qual o problema? Imagine 2 produtores e 2 consumidores e buffer == empty C1 C2 cond Produtor 1 entra e acorda um dos consumidores. Por exemplo, C1

41 41 Qual o problema? Imagine 2 produtores e 2 consumidores e buffer == empty C2 cond Produtor 1 entra e acorda um dos consumidores. Por exemplo, C1

42 42 Qual o problema? Imagine 2 produtores e 2 consumidores e buffer == empty C2 P2 cond Antes que C1 possa executar, um outro produtor (P2) tenta produzir mais um dado. No entanto, o buffer está cheio e ele é colocado na fila

43 43 Qual o problema? Imagine 2 produtores e 2 consumidores e buffer == empty C2 P2 cond C1 finalmente consome elemento do buffer e executa SIGNAL. Qual das threads, C2 ou P2, deve ser acordada? Note que se a C2 for acordada ela novamente vai dormir, já que o buffer estará vazio. O sistema entrará em uma espécie de DEADLOCK!

44 44 Como corrigir o problema anterior? Duas formas principais Primeira (preferida) Usar duas variáveis de condição Uma onde somente as threads esperando pelo evento de buffer vazio (não cheio) esperam, ou seja, as produtoras esperam Outra onde somente as threads esperando pelo evento de buffer cheio (não vazio) esperam, ou seja, as consumidoras esperam Segunda Usar pthread_cond_broadcast(). Por que funciona?

45 45 Semáforos Semáforo é uma primitiva que pode ser usada para qualquer coisa relacionada a sincronização Pode ser usado como mutex ou variável de condição Criado por Edsger Dijkstra Pthreads não suporta a primitiva Pode ser implementada através de mutex e variável de condição Presente no padrão POSIX #include <semaphore.h> Duas operações básicas sem_wait sem_post

46 46 Operações básicas semáforo int sem_wait(sem_t *s) { wait until value of semaphore s is greater than 0 decrement the value of semaphore s by 1 int sem_post(sem_t *s) { increment the value of semaphore s by 1 if there are 1 or more threads waiting, wake 1

47 47 Semáforos como mutexes sem_t m; sem_init(&m, 0, 1); // initialize semaphore to 1 sem_wait(&m); // critical section here sem_post(&m); Valor inicial

48 48 Semáforos como variáveis de condição sem_t s; sem_init(&s, 0, 0); // executed by main thread void * Thread1(void *arg) { /* ação crítica */ sem_post(&s); return NULL; void * Thread2(void *arg) { sem_wait(&s); return NULL;

49 49 Produtor consumidor com semáforos sem_t empty; sem_t full; sem_t mutex; sem_init(&empty, 0, MAX); // MAX buffers are empty to begin with... sem_init(&full, 0, 0); //... and 0 are full sem_init(&mutex, 0, 1); // mutex=1 because it is a lock void *producer(void *arg) { int i; for (i = 0; i < loops; i++) { sem_wait(&empty); sem_wait(&mutex); put(i); sem_post(&mutex); sem_post(&full); // line p3 void *consumer(void *arg) { int i; for (i = 0; i < loops; i++) { sem_wait(&full); sem_wait(&mutex); int tmp = get(); sem_post(&mutex); sem_post(&empty); // line c3 printf("%d\n", tmp);

50 50 Implementando semáforos Construir semáforos a partir de mutexes e variáveis de condição é relativamente simples O inverso não é verdade! typedef struct sem_t { int value; pthread_cond_t cond; pthread_mutex_t lock; sem_t; void sem_wait(sem_t *s) { mutex_lock(&s->lock); while (s->value <= 0) cond_wait(&s->cond, &s->lock); s->value--; mutex_unlock(&s->lock); void sem_post(sem_t *s) { mutex_lock(&s->lock); s->value++; cond_signal(&s->cond); mutex_unlock(&s->lock);

51 51 Barreiras Barreiras são pontos de sincronização A execução só avança quando TODAS as threads atingirem o mesmo ponto barrier_wait(barrier_object) Usos Alguns programas possuem fases de execução só podem prosseguir quando todas as threads finalizarem seus trabalhos Depuração de código Implementável a partir de mutexes e variáveis de condição Versões mais novas de Pthreads já fornecem como tipo