Leandro Soares de Sousa (DSc.) Página: Aula 04 - desenvolvimento multithread

Transcrição

1 Tópicos Especiais Leandro Soares de Sousa (DSc.) Página: Aula 04 - desenvolvimento multithread

2 Mais e mais ferramentas! 2 Processos e Threads: desenvolvimento multithread

3 3 Processos: PCB Código Dados Arquivos propriedade de recursos: a um processo é alocado um espaço de endereçamento virtual para manter a sua imagem; de tempos em tempos o processo pode ter mais memória, além do controle de arquivos, dispositivos de E/S,...

4 4 Processos: PCB Código Dados Arquivos unidade de despacho: um processo é uma linha de execução, intercalada com outras linhas de outros processos; cada uma delas tem um estado de execução e uma prioridade; é a entidade que é escalonada e despachada pelo SO

5 5 Processos: PCB Código Dados Arquivos entra fila despacho UCP sai pausa

6 6 Processos com um e com múltiplos threads: PCB Código Dados Arquivos PCB Código Dados Arquivos Registradores Registradores Registradores Registradores Pilha Pilha Pilha Pilha

7 7 Processos com um e com múltiplos threads: Recursos compartilhados PCB Código Dados Arquivos PCB Código Dados Arquivos Registradores Registradores Registradores Registradores Pilha Pilha Pilha Pilha

8 8 Processos com um e com múltiplos threads: Estas duas características podem ser tratadas de forma independente pelo SO (propriedade de recursos e unidade de despacho): thread ou processo peso leve (lightweight process): é a unidade de despacho processo ou tarefa: é a unidade de alocação de recursos

9 9 Em um ambiente multithreaded, um processo: é a unidade de alocação e proteção de recursos tem um espaço de endereçamento virtual que mantém a imagem do processo tem acesso controlado a outros processos, arquivos e outros recursos

10 10 Em um processo podem existir uma ou mais threads com: um estado de execução (pronta, ) seu contexto salvo quando não estiver executando sua pilha de execução acesso às variáveis locais próprias acesso compartilhado com outras threads deste processo aos recursos do processo

11 11 Principais funções da biblioteca pthread: Header: #include <pthread.h> Compilação: Linux: gcc -o p p.c -lpthread Windows (CodeBlocks): baixe o arquivo pthread.zip do site, depois... copie os *.lib e *.a para: c:\arquivos de Programas (x86)\codeblocks\mingw\lib\ copie os *.dll para: c:\arquivos de Programas (x86)\codeblocks\mingw\bin\ copie os *.h para: c:\arquivos de Programas (x86)\codeblocks\mingw\include\ No CodeBlocks: Project build options linker settings Other linker options: inclua -lpthreadgc1

12 12 Pthread: Declaração de thread (local na main): pthread_t nome_thread; Essa variável recebe um ponteiro para a função executada como uma thread.

13 13 Funções utilizadas: Criação da thread: // variáveis e funções void *funcao() {... } Parâmetros para a thread (ponteiro para void pode ser feito um typecast para uma estrutura, vetor...) pthread_t nome_thread; if (pthread_create(&nome_pthread,null,funcao,null)) { printf("\nerro: criando thread.\n"); return(0); }... pthread_kill(nome_thread,0);

14 14 Mutexes: Servem para travar o acesso: Lock(var) Lock(var) Fica esperando por um unlock(var) para continuar a execução. Utilizado para que não ocorram conflitos no acesso aos recursos compartilhados (por exemplo, variáveis globais) Declaração de mutexes (global): pthread_mutex_t nome_mutex;

15 15 Dinâmica dos mutexes: Init() antes de usar lock e unlock Lock() possivelmente vários ao longo da execução Unlock() possivelmente vários ao longo da execução Fini() antes do final do programa

16 16 Funções utilizadas: Inicialização de um mutex: // inicializa as variáveis de lock, // fazer isto antes do início das threads // lock é só o nome da variável void init_lock(pthread_mutex_t *lock) { pthread_mutex_init(lock,null); return; }... // chamada init_lock(&lock);

17 17 Funções utilizadas: Finalização de um mutex: // finalize as variáveis de lock, // após a finalização das threads // lock é só o nome da variável void fini_lock(pthread_mutex_t *lock) { pthread_mutex_destroy(lock); return; }... // chamada fini_lock(&lock);

18 18 Funções utilizadas: Lock no mutex: pthread_mutex_lock(&lock); Unlock no mutex: pthread_mutex_unlock(&lock);

19 19 Exemplo: Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

20 20 Main Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

21 21 Cabeçalho do programa: #define MWIN #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/time.h> #include <pthread.h> #include <errno.h> #ifdef MWIN #include <windows.h> #endif

22 22 A função main()! Global: Inclusões (cabeçalho) Declaração dos mutexes/buffers/variáveis de controle. Funções main(): Declaração das variáveis dos threads; Iniciar mutexes; Limpar buffers (globais); Iniciar variáveis de controle dos buffers (globais); Gerar entrada(); Iniciar threads, uma a uma, na ordem definida; Rotina de finalização(); Finalizar threads; Finalizar mutexes;

23 23 Gerar entrada: Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

24 24 Gerar entrada(); int gerar_entrada() { FILE *arq; int i; if ((arq = fopen("e.txt","wt"))== NULL) { printf("\nerro: criando o arquivo de entrada!\n"); return(erro); } for (i = 1 ; i <= 1000; ++i) { fprintf(arq,"%05d\n",i); } fflush(arq); fclose(arq); return(ok); }

25 25 Threads (chamadas): Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

26 26 Ativação das threads: as três threads são ativadas na sequência: LEITURA, PROCESSAMENTO e ESCRITA. Dica: criação dos threads, declaração das variáveis e formato do header das funções veja nas transparências anteriores.

27 27 Buffers: Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

28 28 Buffers de entrada e saída: ambos globais e implementados através de um string de tamanho 6 (conteúdo de 5 caracteres e NULL no final) (char be[6],bs[6]; exemplo)

29 29 Mutex para o controle da concorrência: esses mutex: m_e,e m_s, realizam o controle de acesso ao buffer de entrada e ao buffer de saída, respectivamente. Dica: Veja, para definição, inicialização e utilização, nas transparências anteriores.

30 30 Saída: Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

31 31 SAÍDA: Na saída é gerado um arquivo texto (s.txt), contendo 1000 registros, no seguinte formato:

32 32 Threads (funcionalidade): Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

33 33 THREAD LEITURA: a cada um milissegundo lê do arquivo de entrada (e.txt) um novo registro (claro, se o buffer de entrada não estiver cheio). THREAD PROCESSAMENTO: a cada milissegundo lê do buffer de entrada um novo registro e limpa o buffer de entrada, inverte o conteúdo do string lido e grava no buffer de saída, indicando que tem um registro (claro, se tiver algo para ler no buffer de entrada e, depois de completado o processamento, aguarda até que tenha espaço no buffer de saída, pausando em um milissegundo). THREAD ESCRITA: a cada milissegundo, se o buffer de saída estiver com dados então grava em disco e limpa o buffer de saída. DICA: Para ver se tem algo em algum buffer ser criadas duas variáveis globais (Ex.: tem_dado_e e tem_dado_s, com 1 se tem dado e 0 c.c.) DICA: Processamento: ler processar escrever

34 34 Função de apoio: Parada (p) em milissegundos (ms): void m_usleep(unsigned long pause) { #ifdef MWIN Sleep(pause); #else usleep(pause*1000l); #endif return; }... m_usleep(1);

35 35 Threads (algoritmo): Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

36 36 Threads() (Cada uma das 3) fim = 0 // Controle do loop interno for (;;) // Loop externo eterno while (!fim) // Loop interno até finalizar o processamento da thread específica Processamento interno (os buffers não devem ser travados todos ao mesmo tempo) Ao final do processamento altera o terminou e fim = 1 m_usleep(1); // Pausa de 1 milissegundo a cada registro processado Fim do loop interno while Pausa de 1 segundo m_usleep(1000); Fim do loop externo for

37 37 Quando todo o arquivo de entrada for lido, neste momento LEITURA está ponta para terminar, ou seja, fica apenas no loop externo (terminou passa a 2). PROCESSAMENTO só termina quando o buffer de entrada estiver vazio e terminou for igual a 2 (dois), então terminou passa a 1 (um) e processamento fica pronta para terminar, ou seja, fica apenas no loop externo. ESCRITA só termina quando registro de processamento estiver vazio, terminou for igual a 1 (1) e o buffer de saída estiver vazio, terminou passa a 0 (zero), ou seja, fica apenas no loop externo. Quando terminou passa a 0 (zero), a função finaliza acaba e retorna para a função principal. De forma a simplificar a implementação, quando as funções ficam prontas para terminar elas continuam com seu processamento, mas sem alterar mais a variável terminou. (vejam o loop externo da transparência anterior)

38 38 Ordem de execução do programa, criação e término das threads Programa (main) Rotina: Finalizar Rotina: gerar entrada Saída Processamento Entrada Buffer: Saída Buffer: Entrada Saída: s.txt Entrada: e.txt

39 39 ROTINA FINALIZAR() de graça: chamada APÓS a criação de todas as threads, essa rotina fica em loop com paradas de 50 ms, testando a variável terminou (de forma protegida). Criem uma variável global terminou que começa com 3 (três) no início programa, criem um mutex para lock dessa variável (Ex.: p_fi) Terminou a thread de entrada, decrementa terminou Terminou a thread de processamento, decrementa terminou Terminou a thread de saída, decrementa terminou

40 40 ROTINA FINALIZAR(): void finalizar() { int nao_acabou = 1; while (nao_acabou) { m_usleep(50); // 50 milissegundos pthread_mutex_lock(&p_fi); // Protege a terminou if (terminou == 0) { printf("\nem finalizar... Acabou mesmo!"); nao_acabou = 0; } pthread_mutex_unlock(&p_fi);// Desprotege a terminou } return; }

41 Tópicos Especiais Aula 04 - desenvolvimento multithread - FIM