Sistemas Operativos: Threads

Transcrição

1 Sistemas Operativos: Threads Pedro F. Souto March 22, 2011

2 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

3 Processos em Unix Em Unix e SOs dele derivados, como Linux, um processo dispõe essencialmente dum computador virtual: a maioria dos recursos usados por um processo é reservado para seu uso exclusivo; cada processo usa a sua própria memória, a qual, por omissão, não é partilhada com outros processos. Um processo pode ser visto como: Uma máquina virtual para execução de programas em vez de Um programa em execução

4 Comunicação entre Processos em Unix A comunicação entre processos em Unix não é fácil: o processo pai pode passar alguma informação antes de criar o processo filho, mas depois... o processo filho só pode retornar informação (e muito limitada) ao processo pai quando termina; sincronização entre processos só entre o pai e os seus filhos. Suporte de memória partilhada entre processos pelo SO: + facilita a cooperação entre processos; não é muito conveniente de usar; é relativamente ineficiente, já que requer a intervenção do SO para sincronização.

5 Threads Threads abstraiem a execução duma sequência de instruções. Grosso modo, enquanto que um processo corresponde à execução dum programa, um thread corresponde à execução duma função. Em SOs mais recentes, um processo pode incluir mais do que um thread. Text Text Data Data

6 Processador de Texto Multithreaded A ideia é usar um thread por tarefa. Four score and seven nation, or any nation lives that this nation who struggled here here to the unfinished they gave the last full years ago, our fathers so conceived and so might live. It is have consecrated it, far work which they who measure of devotion, brought forth upon this dedicated, can long altogether fitting and above our poor power fought here have thus that we here highly continent a new nation: endure. We are met on proper that we should to add or detract. The far so nobly advanced. resolve that these dead conceived in liberty, a great battlefield of do this. world will little note, It is rather for us to be shall not have died in and dedicated to the that war. But, in a larger sense, nor long remember, here dedicated to the vain that this nation, proposition that all We have come to we cannot dedicate, we what we say here, but great task remaining under God, shall have men are created equal. dedicate a portion of cannot consecrate we it can never forget before us, that from a new birth of freedom Now we are engaged that field as a final cannot hallow this what they did here. these honored dead we and that government of in a great civil war resting place for those ground. The brave It is for us the living, take increased devotion the people by the testing whether that who here gave their men, living and dead, rather, to be dedicated to that cause for which people, for the people Keyboard Kernel Disk 1. Um thread para interagir com o utilizador (teclado e rato); 2. Um thread para formatar o texto (em background); 3. Um thread para guardar o ficheiro periodicamente no disco.

7 Partilha de recursos com Threads Threads dum mesmo processo podem partilhar a maior parte dos recursos, com excepção da stack e do estado do processador: Thread 2 Thread 1 Thread 3 Process Thread 1's stack Thread 3's stack Kernel

8 Estado dum Thread Tal como um processo, um thread pode estar num de 3 estados: running 1 ready 2 3 waiting A informação específica a manter por cada thread é relativamente reduzida: o seu estado (pode estar bloqueado à espera dum evento); o estado do processador (incluindo o SP e PC); a stack. 4

9 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

10 Uso de Threads Threads dum mesmo processo podem partilhar muitos recursos, incluindo o espaço de endereçamento: são particularmente apropriados para aplicações consistindo em actividades concorrentes. P.ex. servidor da Web: Recebe e processa pedidos de páginas da Web. As páginas da Web são ficheiros guardados em disco. Mantém as páginas acedidas mais recentemente em memória, cache. Se a página pedida não estiver na cache, o servidor tem que ir ao disco.

11 Servidor da Web com um Único Thread while( TRUE ) { get_next_request(&buf); lookup_page_in_cache(buf, &page); if( page == NULL ) read_page_from_disk(buf, &page); send_page(page); } Se a página pedida não estiver na cache, o servidor tem que ir ao disco, bloqueando. Enquanto a página não fôr trazida para memória, o servidor não pode processar outros pedidos. O número de pedidos que este servidor pode processar por unidade de tempo é muito baixo.

12 Servidor da Web com E/S Sem Bloqueio Alguns SOs suportam chamadas ao sistema de E/S que não bloqueiam o processo que as invoca. Posteriormente: o processo pode interrogar o kernel sobre a conclusão da operação (non-blocking I/O); alternativamente, o kernel pode notificar o processo da conclusão da operação (asynchronous I/O). Se a página pedida não estiver na cache, o servidor pode executar uma operação de E/S sem-bloqueio/assíncrona. Depois, pode receber e processar a mensagem seguinte. O servidor tem que manter informação sobre o estado de processamento de cada pedido pendente. Este tipo de solução diz-se event driven, ou baseada numa finite-state machine.

13 Servidor da Web com Múltiplos Threads Um thread, o dispatcher, recebe os pedidos e passa-os a outros threads, os worker. Cada worker thread processa um pedido de cada vez: pode usar operações de E/S que bloqueiem. Web server process Dispatcher thread Worker thread User space Web page cache Kernel Kernel space Network connection

14 Servidor da Web com Múltiplos Threads Código do dispatcher thread: while( TRUE ) { get_next_request(&buf); handoff_work(buf); } Código dos worker threads: while( TRUE ) { wait_for_work(&buf); lookup_page_in_cache(buf, &page); if( page == NULL ) read_page_from_disk(buf, &page); send_page(page); }

15 Servidor da Web: Comparação Modêlo Paralelismo Programação Thread único Não Fácil. Event-driven Sim Trabalhosa. Multi-threaded Sim Nem sempre fácil.

16 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

17 Implementação de threads Threads podem ser implementados: 1. directamente pelo SO (kernel-level threads); 2. por código que executa em user-level, i.e. acima do SO, (user-level threads).

18 Kernel-level Threads O kernel suporta processos com múltiplos threads: os threads são as entidades que disputam o CPU. O SO mantém uma tabela de threads com a informação específica a cada thread. O PCB dum processo aponta para a sua tabela de threads. Todas as operações de gestão de threads, p.ex. criar um thread, requerem a execução de chamadas ao sistema.

19 User-level Threads O kernel não sabe da existência dos threads: são implementados inteiramente por uma biblioteca em user-space; podem ser implementados num SO que não suporta threads.

20 Implementação de User-level Threads A biblioteca de threads oferece funções que permitem: criar/terminar threads; sincronizar entre threads; ceder o CPU a outros threads (yield); A biblioteca executa a comutação entre threads e mantém uma tabela de threads. Funções que encapsulam chamadas ao sistema que podem bloquear têm que ser alteradas: para evitar que todos os threads bloqueiem. Algumas dificuldades: como executar chamadas ao sistema sem bloquear? e page-faults? como evitar que um thread monopolize o CPU?

21 User-level vs. Kernel-level Threads + O SO não precisa suportar threads. + Evita a intervenção do kernel em muitas operações, p.ex. criação/terminação de threads e comutação de threads. Page-fault por um thread bloqueia os restantes threads do processo. Incapazes de explorar paralelismo em arquitecturas multiprocessador.

22 Implementação Híbrida A ideia é multiplexar user-level threads sobre kernel-level threads Multiple user threads on a kernel thread User space Kernel Kernel thread Kernel space O kernel não está a par dos user-level threads. A biblioteca de user-level threads atribui estes aos kernel-level threads.

23 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

24 libpthread (pthreads) Biblioteca de threads especificada em POSIX: A sua utilização promove portabilidade do código. Esta biblioteca pode ser implementada usando: kernel-level threads, p.ex. a biblioteca distribuída com Linux; user-level threads, p.ex. algumas bibliotecas disponíveis para Linux; usando ambos tipos de threads, p.ex. a biblioteca distribuída com Solaris.

25 Funções básicas de gestão de threads int pthread_create(pthread_t *id,...) cria um thread que executa a função especificada no seu argumento: Function invocation vs thread creation fun() fun() fun() pthread_create() void pthread_exit(void *value_ptr) termina o thread; int pthread_join(pthread_t thread, void **value_ptr) espera que o thread especificado no argumento thread termine.

26 Execução de Programas Multithreaded Num programa multithreaded um thread é criado quando: O programa inicia: main() é executado pelo thread principal. Quando da invocação de pthread_create(): todos os outros threads. Um thread termina se, p.ex.: retorna da função inicial que executou (argumento de pthread_create() ou main()); executa pthread_exit(). Um programa multithreaded termina se, p.ex.: O thread principal terminar (ver acima); Qualquer thread invocar a chamada ao sistema _exit().

27 pthread_create() int pthread_create(pthread_t *id, const pthread_att_t attr, void *(*start_fn)(void *), void *arg) onde: *id será inicializado com a identidade do thread criado; *attr é uma estrutura de dados que configura o modo de funcionamento: pode ser inicializada com valores por omissão usando: int pthread_attr_init(pthread_attr_t *attr) *start_fn uma função com o seguinte protótipo: void *thr_fun(void *) que é a primeira função executada pelo thread a criar. *arg é a estrutura de dados a passar à função thr_fun().

28 pthread_create(): exemplo #include <pthread.h> void *fun(void *arg) { /* Actually the ar- */... /* gument is not used */ }... pthread_attr_t attr; pthread_t tid;... pthread_attr_init(&attr); /* Initialize attr * default values * pthread_create(&tid, &attr, fun, NULL);... No caso geral, o último argumento de pthread_create() é o endereço duma estrutura de dados contendo os argumentos da função fun().

29 void *fun(void *arg) Permite definir praticamente qualquer função. Para evitar avisos (warnings) do gcc o mais fácil é definir um tipo de apontador para uma função. #include <pthread.h> typedef void *(thr_fun_t)(void *arg); int *fun(int *arg) {... }... pthread_attr_t attr; pthread_t tid; int thr_arg;... pthread_attr_init(&attr); /* Initialize attr */ pthread_create(&tid, &attr, (thr_fun_t *) fun, (void *)&thr_arg);...

30 Múltiplos Threads Normalmente applicações multithreaded usam mais do que 2 threads É necessário alocar variáveis diferentes para cada thread. #include <pthread.h> #define T 3 /* number of threads */ typedef void *(thr_fun_t)(void *arg);... pthread_attr_t attr[t]; pthread_t tid[t]; int thr_arg[t];... for( i = 0; i < T; i++ ) { pthread_attr_init(&attr); /* Initialize attr */ pthread_create(&(tid[i]), &(attr[i]), (thr_fun_t *) fun, (void *)&(thr_arg[i])); }...

31 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

32 variáveis globais: Thread 1 Thread 2 Programação com Múltiplos Threads Código escrito para processos com um único thread raramente funciona correctamente com múltiplos threads: Time Access (errno set) Open (errno overwritten) Errno inspected funções não reentrantes; concorrência (race conditions). Esta observação aplica-se também a código das bibliotecas, incluindo a C standard library : Com gcc, deve usar-se a opção -D_REENTRANT

33 Sumário Conceito de Thread Uso de threads Implementação de Threads Libpthreads Problemas da Programação com Threads Leitura Adicional

34 Leitura Adicional Secção 2.2 de Modern Operating Systems, 2nd Ed. Secções 3.5 e de José Alves Marques e outros, Sistemas Operativos, FCA - Editora Informática, 2009 Outra documentação (transparências e enunciados dos TPs):