Sistemas OperativosProcessos, threads e eventos

Rui Maranhão (rma@fe.up.pt)

Multi-tarefa

• execução, em paralelo, de programas no mesmo computador

• cada instância em execução denomina-se processo (conceito central num SO!)

• pseudo-paralelimo: execução de sistemas multiprograma num computador com um único processador

Pseudo-paralelismo

• Porquê pseudo?

•

Processos vs. Programas

• programa é um ficheiro executável

• um processo é um objecto do sistema operativo que suporta a execução dos programas

• um processo pode executar vários programas

• um programa ou partes dele podem ser partilhados por diversos processos (*.dll)

Processo como máquina virtual

• um processo tem

• espaço de endereçamento

• repertório de instruções

• contexto de execução (estado interno)

Hierarquia

• informação nos subprocessos são herdadas

•

Processos

• o contexto de execução de um processo (ou seja, o seu estado) compreende

• código

• dados

• estado do processador (registos)

• recursos (ficheiros, ...)

• tempo CPU consumido

Informação sobre um processo

Processo

• SO deverá ser capaz de

• criar, suspender, e reiniciar a execução de processos

• suportar comunicação entre processos

• o próprio SO tem muitos processos “do sistema”

Processos

• competem por recursos para executar as suas tarefas

• cabe ao sistema operativo fazer o escalonamento dos processos

Estados de um processo

Estados de um processo

• em execução

• foi-lhe atribuído CPU

• bloqueado

• o processo está logicamente impedido de prosseguir, porque lhe falta um recurso

• do ponto de visto do SO, transição voluntária

• pronto a executar, aguarda escalonamento

Primitivas de despacho

• bloqueia(evento)

• coloca processo na fila de processos parados à espera do evento

• invoca próximo processo

• liberta(evento) ou liberta(processo, evento)

• se processo não esta a espera de mais eventos, coloca-o na lista de espera

Primitivas de despacho

• proximo_processo()

• selecciona um dos processos existentes na lista de processos prontos a executar

• executa a comutação de contexto

• salvaguarda contexto volátil do processo corrente

• carrega contexto do processo escolhido

Principais decisões

• Qual o próximo processo?

• Quando começa a executar?

• Durante quanto tempo?

• ou seja: há desafectação forçada ou não?

Criação de um processo

• id = criarProc(codigo_fonte, prioridade, ...)

Eliminação de processos

• eliminação do processo quando o programa termina, eliminando dados e recursos

• sair([estado]), estado = erro \/ !erro

• eliminação de outro processo

• eliminarProc(id)

• erro fatal (segmentation fault)

Terminação de processo filho

• em certos casos, o processo pai pode querer bloquear esperando a terminação do processo filho

• estado = esperaTerminacao(id)

Multiprogramação - Benefícios -

• maximiza o tempo de utilização do CPU

• utilização do CPU = 1 - pn

• n é o número de processos

• p fracção de tempo em espera por I/O

•

Unix - Processos

• ... sobre o ponto de vista do utilizador

Processos em Unix

• identificação de um processo

• inteiro pid

• alguns pid’s estão pre-atribuídos

• 0 é o swapper (gestão de memória)

• 1 é o init (inicialização do sistema)

Processos em Unix

• os processos relacionam-se de forma hierárquica

• o processo herda o ambiente do pai

• o processo sabe o pid do pai

• se processo pai terminar, os subprocessos são adoptados pelo pid=1

Processos em Unix

• espaço de endereçamento (modo utilizador)

• três zonas (segmentos)

• .text, dados, e stack

• espaço de endereçamento (modo kernel)

• zona de dados e stack no kernel

Processos em Unix

• processos também tem associado um contexto de execução em modo utilizador contendo as variáveis de ambiente

• HOME, SHELL, PATH, ...

• herdado do processo pai

• em C é acessível através do parâmetro do main ou de uma variável externa

main (arc, arv, envp)extern char **environ

Criação de um Processo

• id = fork()

• retorna o pid do processo

• pai = pid do filho

• filho = 0

• -1 erro

• sem parâmetros ; imagem do filho é uma cópia do criador

Exemplo de fork()

Terminação

• termina o processo, e liberta todos os recursos detidos pelo processo

• assinala ao processo pai a terminação

• void exit(status)

• status permite passar ao pai o estado em que o processo terminou (<0 = erro)

Terminação

• em unix existe uma função para o processo pai se sincronizar com a terminação de um processo filho

• bloqueia o processo pai até que o filho termine

• int wait(int *status)

• status - estado de terminação do filho

• retorna o pid do processo terminado

Exemplo de Sincronização

Execução de um programa

• o fork apenas permite lançar processo com o mesmo código!

• a função exec permite substituir a imagem do processo onde é invocada

• não há retorno numa chamada com sucesso

• parâmetros: valores passados

• ficheiros matem-se abertos

Execução de um programa

• int execl(char *fich, arg0,...argn, 0)

• int execv(char *fich, *argv[])

• fich = caminho do ficheiro

• argv = argumentos

Exemplo de exec

Shell

• shell é um bom exemplo de fork e exec

•

Autenticação

• um processo tem associado 2 ids atribuídos aquando do login (uid, gid)

• uid e gid são obtidos no ficheiro /etc/passwd

• uid e gid são herdados pelos filhos

• superuser é um uid especial (0, associado ao utilizador root)

Protecção

• protecção de recursos em unix é semelhante ao modelo listas de controlo de acesso

• protecção definida em três categorias

• dono (owner)

• grupo (group)

• restantes (world)

Set uid

• mecanismo de set uid (suid) permite alterar dinamicamente o utilizador

• duas variantes

• bit de setuid

• função de sistema setuid

Bit setuid

• ficheiro executável pode conter uma indicação especial para provocar a alteração do uid

• processo assume identidade do dono

• exemplo: passwd

• operação crítica para segurança!!

Threads

• ... múltiplos fluxos de execução no mesmo processo

Threads

• mecanismo para criar fluxos de execução, partilhando um contexto comum

•

Threads vs. processos

• Porque não usar processos?

• processos obrigam ao isolamento

• espaços de endereçamento disjuntos

• dificuldade em partilhar

• Eficiência na criação e comutação

Threads: exemplos

• servidor (e.g., web)

• processador de texto

• quais as threads em cada caso??

Threads: operações

• operações sobre as threads

• id = criarThread(procedimento)

• eliminarThread(id)

• esperarThread(id)

API POSIX

• err = pthread-create(&tid, attr, func, arg)

• tid = id da tarefa ; attr = atributos

• func = função a executar

• arg = parâmetros para a função

• pthread-exit(void *value_ptr)

• int pthread-join(pthread_t thread, void **value_ptr)

• se a tarefa alvo não terminou bloqueia-se

Exemplo sequencial

Exemplo com threads

ThreadsPOSIX vs. Windows

Tarefas Criar Sincronizar com Terminacao Transferir controlo adormecer terminarPOSIX pthread create pthread join pthread yield sleep pthread exit

Windows CreateThread WaitForSingleObject SwitchToThread sleep ExitThread

Programação em ambiente multitarefa

• threads partilham o mesmo endereçamento

• acesso às mesmas variáveis globais

• modificação de variáveis globais deve ser feito com precaução

• para resolver estes problemas, sincronização é essencial (falado adiante)

Implementação

• threads núcleo

• threads utilizador

threads utilizador

• as tarefas são implementadas numa biblioteca no espaço de endereçamento do utilizador

• ideia proveniente das LP

• núcleo apenas vê um processo

• processo guarda lista de tarefas

threads utilizador

• comutação entre tarefas é explicita

• thread-yield

• pode ser contornado usando interrupções

• problema: e se uma tarefa faz chamada bloqueante??

• Solução?

threads núcleo

• implementação no núcleo do SO

• mais comuns

• lista de tarefas é gerido pelo núcleo

threads núcleo vs. utilizador

• capacidade de utilização em diferentes SO?

• velocidade de criação e comutação?

• tirar partido da execução paralela em multiprocessadores?

• aproveitamento do CPU quando uma tarefa bloqueia?

Eventos

• ... Rotinas para tratamento de acontecimentos assíncronos e excepções

Rotinas assíncronas

• certos acontecimentos devem ser tratados, embora não seja possível prever a sua ocorrência

• ctr-c, time-out, div-0

• como tratá-los na programação sequencial?

• uma thread por acontecimento?

• Alternativa: eventos!

Eventos

• semelhante a outro conceito... qual?

Rotinas Assíncronas

• rotinaAssincrona(evento, procedimento)

Signals

• ... são acontecimentos assíncronos em unix

• definidos em signal.h

• man signal para mais info

Tratamento de signals

• omissão - termina o processo

• ignorado - alguns sinais não podem ser ignorados (ex., SIGKILL)

• associado a uma rotina de tratamento (handler)

• usando a função signal

Chamada de sistema: signal

• void (*signal (int sig, void (*func)(int)))(int)

Exemplo: signal

Chamada de sistema: kill

• envia um signal ao processo pid

• nome da função bem escolhido?!

• kill(pid, sig)

Outras funções associadas aos signals

• unsigned alarm(unsigned int sec)

• depois de sec segundos SIGALARM é enviado para o processo

• pause()

• aguarda a chegada de um signal

• unsigned sleep(unsigned int sec)

• faz alarm e bloqueia-se a espera do signal

Sumário

• programa vs. processo vs. thread

• mecanismos em sistemas unix

• eventos

• para que servem e como funcionam