so-02 processos

Processos Introdução

2 Processos - Introdução Eduardo Nicola F. Zagari

Conceito de Processo Escalonamento de Processo Operações em Processos Threads


Um sistema operacional executa uma variedade de programas: Sistemas Batch – jobs Sistemas time-sharing – programas de usuários ou tasks (tarefas)

Processo programa em execução

Primeiros sistemas computacionais somente um programa era executado em cada momento (dominando todos os recursos)

Sistemas atuais vários programas executando concorrentemente (multiprogramação), exigindo maior controle e compartimentalização dos vários programas

processo


Processo é mais do que o código do programa: contador de programa (PC), registradores do processador, pilha (parâmetros de subrotinas, endereço de retorno, variáveis

temporárias), variáveis globais

Vários processos podem estar associados a um único programa

Programa (passivo) x Processo (ativo)


Em um SO com multiprogramação, um processo, du-rante sua existência, passa por uma série de estados

Basicamente, os estados de um processo são: novo: o processo é criado em execução/rodando: se está associado a um

processador que está executando suas instruções pronto para execução: se o processo aguarda sua vez

para executar (processador indisponível) bloqueado/espera: se o processo aguarda que ocorra

algum evento para continuar a executar (término de E/S, recepção de sinal)

término: o processo terminou sua execução


Desde o instante que um processo é iniciado, o seu estado passa pelas seguintes transições: 1. uma CPU fica disponível para o processo, que passa do estado de

pronto para o de execução 2. o processo necessita de algo que não está disponível para

continuar a ser executado, assim, passa de em execução para bloqueado, aguardando a satisfação de sua necessidade

3. a necessidade do processo é satisfeita, podendo então passar de bloqueado/espera para pronto para execução

4. o uso da CPU exclusivamente por um só processo deve ser evitado, para isso pode existir um tempo máximo em exe-cução contínua, após o qual o processo passa de em execução para pronto, permitindo que outro processo use a CPU


pronto

bloqueado

execução

término

novo

E/S ou evento

início

fim

escalonado

interrupção espera por E/S ou evento


BCP representa o processo no SO, mantendo a informação associada com cada um: estado do processo: pronto, bloqueado, em execução, ... PC: endereço da próxima instrução registradores da CPU: variam em no e tipo dependendo da

arquitetura informação de escalonamento da CPU: prioridade, ponteiro para

fila de escalonamento, etc informação de gerência de memória: registradores base e limite

de memória, tab. de páginas e/ou tab. de segmentos informação sobre recursos: quantidade de CPU usada, limite de

tempo de uso, no processo, no do job informação de estado de E/S: lista de dispositivos alocados, lista

de arquivos abertos, ...


Lista de arquivos abertos

. . .

PID

Estado do processo

PC

Registradores

Limites de memória


salva contexto em BCP0 . . . carrega contexto de BCP1

P0 P1 executando

SO interrupção ou chamada de sistema

interrupção ou chamada de sistema

salva contexto em BCP1 . . . carrega contexto de BCP0

executando

executando ocioso

ocioso

ocioso


Objetivo da multiprogramação: maximizar utilização da CPU Filas de escalonamento:

fila de pronto: lista ligada com todos os processos no estado de pronto (organizada segundo uma política de seleção)

filas de dispositivos: listas dos processos que fizeram requisição de E/S e aguardam a liberação do dispositivo

Em seu ciclo de vida, o processo migra de uma fila para outra (ação do escalonador)


início fim

Fita magnética

BCP7

. . .

PID

registradores

BCP2

. . .

PID

registradores início fim

Fila de pronto

início fim

Unidade terminal 0

BCP5

. . .

PID

registradores

BCP3

. . .

PID

registradores

BCP14

. . .

PID

registradores

BCP6

. . .

PID

registradores início fim

Unidade de disco 0


fila de pronto CPU

aguarda uma interrupção

fork

time slice expirado

fila de E/S E/S

filho termina

executa filho

ocorre interrupção

requisição de E/S


Escalonador age sobre a fila de processos prontos de maneira a escolher qual é o próximo a ser executado

Escalonador de CPU (ou escalonador de curto prazo): seleciona qual processo deve ser o próximo a ser executado e aloca a CPU para ele. Executado freqüentemente (milisegundos) Deve ser rápido

Escalonador de job (ou escalonador de médio prazo): seleciona qual processo deve ser trazido para a fila de pronto. Executado pouco freqüentemente (segundos, minutos) Pode ser lento Controla o grau de multiprogramação


Processos podem ser descrito de acordo com o tipo de processamento que executam: CPU-bound (ligado à CPU): passa a maior parte do tempo no

estado fazendo cálculos (em execução) e realiza poucas operações de E/S (aplicações matemáticas e científicas) Poucas e longas ʻrajadasʼ de uso de CPU

I/O-bound (ligado à E/S): passa a maior parte do tempo no estado bloqueado, pois realiza muitas operações de E/S (aplicações comerciais e interativas) Muitas e curtas ʻrajadasʼ de uso de CPU

tempo

CPU

I/O

tempo

CPU

I/O


Quando a posse da CPU é atribuída a outro processo, o sistema deve salvar o estado do processo antigo e carregar o estado do processo novo

O tempo de troca de contexto é uma sobrecarga O sistema não realiza trabalho útil enquanto realiza o chaveamento

O tempo depende do hardware


Um processo (dito Processo Pai) pode criar novos processos (ditos Processos Filhos) via chamada de sistema Um processo filho, por sua vez, pode criar outros processos,

formando uma árvore de processos usuário pode solicitar a criação a um shell, que entende o pedido do

usuário através de uma linguagem dita de controle (textual, gráfica, por eventos)

Compartilhamento de Recursos (memória, arquivos, dispositivos de E/S) Pai e filho compartilham todos os recursos Filho compartilha um subconjunto dos recursos do pai Pai e filho não compartilham recursos

Execução Pai e filho executam concorrentemente Pai espera até o término do filho


Espaço de endereçamento do novo processo Processo filho é uma cópia do processo pai Processo filho tem um programa carregado nele

Exemplo de chamadas de sistema do UNIX fork(): cria um novo processo exec(): usado depois de um fork() para substituir o espaço de

memória do processo por um novo programa main() {

int pid; pid = fork(); if (pid < 0) { /* fork failure */ } else if (pid > 0) { /* parent code */ } else { /* child code */ }


#include <stdio.h>#include <unistd.h>int main(int argc, char *argv[]){int pid; /* fork another process */ pid = fork(); if (pid < 0) { /* error occurred */ fprintf(stderr, "Fork Failed"); exit(-1); } else if (pid == 0) { /* child process */ execlp("/bin/ls","ls",NULL); } else { /* parent process */ /* parent will wait for the child

to complete */ wait(NULL); printf("Child Complete"); exit(0); }}


Processo executa sua última instrução e pede ao SO para terminá-lo (exit) Dados de saída do filho para o pai (via wait) exit(): todos os recursos do processo são liberados pelo SO

Um processo pai pode terminar a execução de um processo filho via chamada de sistema Filho excedeu os recursos alocados A tarefa atribuída ao filho não é mais necessária Se o pai está terminando

Alguns sistemas operacionais não permitem que o filho continue se o pai terminou – Todos os filhos terminam – terminação em cascata


Uma thread (ou lightweight process, isto é, um processo leve) é a unidade básica de utilização da CPU. Ela consiste de: Contador de programa (PC) Conjunto de registradores Espaço de pilha

Uma thread compartilha com suas threads parceiras suas: Seção de código Seção de dados Recursos do sistema operacional Coletivamente conhecidas como uma tarefa (processo).

Um processo tradicional (ou heavyweight process) é igual a uma tarefa com uma única thread

As threads operam como processos: estado/criam outras threads, etc


Em um processo multithread, enquanto uma thread servidora está bloqueada e esperando, uma segunda thread do mesmo processo pode executar. A cooperação de múltiplas threads de um mesmo processo

confere a ele melhor desempenho (redução do tempo de troca de contexto).

Aplicações que requerem o compartilhamento de um buffer comum (i.e., produtor-consumidor) se beneficiam da utilização de threads.

Threads provêem um mecanismo que permite a processos seqüenciais fazerem chamadas de sistema bloqueantes enquanto também alcançam paralelismo.


Threads podem ser: Suportadas pelo Kernel (Mach, OS/2, WinXP/200, Linux 2.6). Nível de usuário, suportadas acima do kernel, via uma biblioteca de

funções (Project Andrew da CMU, POSIX (Linux 2.4), Java, Win32). Abordagem híbrida, que implementa ambas (Solaris 2).

so-02 processos

Technology