1) A programação concorrente é necessária para utilizar o processador completamente e modelar o paralelismo do mundo real. 2) Existem diferentes formas de implementar tarefas concorrentes, como multiprogramação, multiprocessamento e processamento distribuído. 3) Problemas de concorrência como condições de disputa e regiões críticas devem ser resolvidos com técnicas como exclusão mútua e semáforos.

1. Programação concorrente (processos e threads )

2. Por que precisamos dela? Para utilizar o processador completamente Paralelismo entre CPU e dispositivos de I/O Para modelar o paralelismo do mundo real

3. Para que mais de um computador/processador possa ser utilizado para resolver

4. o problema Considere como exemplo encontrar o caminho através de um labirinto Programação concorrente

5. Busca Sequencial no Labirinto

6. Busca Concorrente no Labirinto

7. Há um longo debate sobre se a concorrência deve ser definida na linguagem de programação ou deixada para o sistema operacional Ada, Java e C# fornecem concorrência

8. C e C++ não Concorrência na linguagem ou no SO?

9. Formas de implementar uma coleção de tarefas executando concorrentemente Multiprogramação as tarefas multiplexam suas execuções num único processador (pseudo-paralelismo) Multiprocessamento as tarefas multiplexam suas execuções num sistema multiprocessador onde

10. há acesso a uma memória compartilhada (acoplamento forte. e.g.: multicore) Processamento distribuído as tarefas multiplexam suas execuções em vários processadores que não

11. compartilham memória (acoplamento fraco. e.g. LAN´s, WAN,s) Implementação de tarefas concorrentes

12. Inclui: contador de programa (PC), pilha, dados Conceito de processo

13. Estados de um processo (tarefa)

14. Process Control Block (PCB)

15. Chaveamento de contexto

16. Árvore de Processos

17. Memória compatilhada

18. Troca de mensagens

19. Pipes

20. Semáforos

21. Monitores

22. Sockets

23. RMI ( remote method invotation )

24. RPC ( remote procedure calls ) IPC (comunicação entre processos)

25. Problemas de concorrência Condições de disputa: o resultado depende da ordem de execução (imprevisível)

26. Regiões críticas: partes do código onde ocorrem as condições de disputa. Solução:

27. exclusão mútua e.g. Memória compartilhada : x=x+1; carrega o valor de x num

28. registrador, incrementa, armazena o valor do registrador em x. Princípios para boa solução de exclusão mútua 1) Nunca dois processos simultaneamente em suas regiões críticas 2) Nada pode ser afirmado sobre velocidade ou número de CPUs 3) Nenhum processo fora da sua região crítica pode bloquear outros 4) Nenhum processo pode esperar eternamente para entrar em sua região crítica t1 t2 t3 t4 P4 P3 P2 P5 request start release leave

29. São números inteiros: typedef int Semaphore;

30. Seu valor pode apenas ser inicializado: Semaphore x = 0; Não pode ser manipulado diretamente x++;

31. x--;

32. x=10; A manipulação tem que ser feita através de duas primitivas: down e up down :diminui o valor do semáforo (bloqueia se <0) down(&x); up : aumenta o valor do semáforo (desbloqueia se <0) up(&x); Nomes alternativos:

33. down = wait = P

34. up = signal = V Semáforos

35. de usuário e de núcleo Threads (fluxos de execução) Modelo antigo: uma thread por processo Modelo novo: várias threads por processo Dados que devem ser mantidos para cada thread

36. Muitos para um Modelos multithreading muitos para muitos um para um

37. Problemas clássicos de sincronização Produtor-consumidor (buffer limitado) Semaphore mutex=1; Semaphore vazios=N; Semaphore cheios=0; void produtor (void) { while(true){ // produz item down(&vazios); down(&mutex); // adiciona item up(&mutex); up(&cheios); } } void consumidor (void) { while(true){ down(&cheios); down(&mutex); // remove item up(&mutex); up(&vazios); // consome item } } Produtor Consumidor Buffer Cheios Vazios consumidor produtor

38. Problemas clássicos de sincronização Rendez-vous Semaphore x=0; Semaphore y=0; void thread1 (void) { // a1 up(&x); down(&y); // a2 } void thread2 (void) { // b1 up(&y); down(&x); // b2 } Considere o código abaixo e suponha que se deseje que a Instrução a1 seja executada antes de b2 e b1 antes de a2 void thread1 (void) { // a1 // rendez-vous // a2 } Void thread2 (void) { // b1 // rendez-vous // b2 }

39. Problemas clássicos de sincronização Leitores e Escritores Bloco de Dados leitor leitor escritor escritor

40. Assíncrona (sem espera) Requer armazenamento de mensagens ( buffer ) -> buffers potencialmente infinitos O que fazer quando o buffer estiver cheio?

41. void send (Task destino, Msg msg);

42. void receive (Task origem, Msg *msg); Sincronização e comunicação baseadas em mensagens Tarefa P1 Tarefa P2 send message receive message message tempo tempo

43. Síncrona Não requer buffer Facilita a implementação

44. Conhecida como Rendezvous void send (Task destino, Msg msg); void receive (Task origem, Msg *msg); Sincronização e comunicação baseadas em mensagens send message receive message time time blocked M

45. Remote invocation (e.g. Ada) Conhecida como rendezvous estendida Status send (Task destino, Msg msg); Status receive (Task origem, Msg *msg); Sincronização e comunicação baseadas em mensagens Task P1 Task P2 send message receive message time time blocked M reply

46. Nomeação das tarefas Direta -> simplicidade

47. O transmissor nomeia o receptor explicitamente

48. void send( Task t, Msg m);

49. Indireta -> auxilia a decomposição do software (a mailbox pode ser vista

50. como uma interface entre as várias partes do programa)

51. o transmissor nomeia uma entidade intermediária (canal, mailbox , link ou

52. pipe )

53. void send( MailBox mb, Msg m); Sincronização e comunicação baseadas em mensagens

54. Nomeação das tarefas Simética

55. Ambos, TX e RX, nomeiam um ao outro (ou à caixa de correio).

56. void send( Task t, Msg m);

57. void receive( Task t, Msg m);

58. void send( Mailbox mb, Msg m);

59. void receive( Mailbox mb, Msg *m);

60. Assimétrica

61. o receptor não nomeia a origem e recebe mensagens de todas as tarefas (ou de

62. todas as caixas de correio) void receive (Msg *m); Sincronização e comunicação baseadas em mensagens

63. [1] Real-Time Systems and Programming Languages . Burns A., Wellings A. 2nd edition [2] Análise de Sistemas Operacionais de Tempo Real Para Applicações de Robótica e Automação. Aroca R. V. Dissertação de Mestrado. [3] Operating System Concepts . Silberschatz, Galvin, Gagne. 8 th edition

64. [4] Sistemas Operacionais Modernos. Tanenbaum 2a edição Bibliografia