Processos: · Criação e remoção de processos (do sistema e dos usuários) · Suspensão e ativação de processos · Sincronização de processos · Comunicação entre processos · Tratamento de deadlock entre os processos Memória: · Manter informação sobre quais partes da memória estão sendo usadas no instante atual e por quem · Decidir quais processos devem ser carregados na memória quando algum espaço de memória se torna disponível · Alocar espaço e remover programas e dados da memória quando necessário

Um processo corresponde a um programa em execução. Normalmente o termo programa é utilizado para definir o código do mesmo e o termo processo para se referir à ativação do mesmo, incluindo código, dados, arquivos e outros recursos necessários à sua execução. Em alguns casos, um mesmo programa pode fazer parte de vários processos. Um processo pode conter um único thread (processo pesado) ou vários (processo leve). Cada thread compartilhando o mesmo código mas executando "paralelamente".

Na criação de novos processos, para que haja compartilhamento de todos os recursos alocados para o processo pai, o processo filho deve ser uma cópia do pai. Isso implica em armazenar todas as informações, que estão armazenadas no espaço de endereçamento do processo pai, no espaço de endereçamento do processo filho. Cada processo consiste de contador de programas, seção de dados e código, ponteiro de pilha de execução e registradores. Todos esses dados são copiados para o novo processo. Na criação de uma thread, é criado um espaço de endereçamento (dentro do espaço do processo) com um contador de instruções, registradores e um espaço de pilha para aquela thread. Todas as outras informações existentes no espaço de endereçamento do processo (que é comum para todas as threads) não precisam ser replicadas e podem ser utilizadas por todas as threads que fazem parte do processo. Ou seja, o tempo de criação e alocação de espaço para criar a thread é menor do que para criar o processo, fazendo c/ que a criação de threads seja mais barata do que a de processos. As thread compartilham a seção de dados e de código e os recursos do sistema operacional com as demais threads do processo.

Cada processo é descrito no SO por um Bloco de controle de processos (BCP) e cada thread é descrita no processo por um bloco de controle próprio (BCT). No BCP há informações: compartilhadas (espaço de endereçamento, variáveis globais, arquivos abertos, temporizadores, sinais, semáforos e contabilização de recursos) e específicas (processos filhos, contador de programa, pilha, conjunto de registradores e informações sobre o estado do processo). No BCT, há informações: específicas (contador de programa, pilha, conjunto de registradores e informações sobre o estado do thread). Na troca de contextos entre processos, o SO armazena o estado do processo atual e recupera o estado do processo que será executado realizando as seguintes operações: · atualiza o estado do processo, o contador de programa e outras informações do BCP · salva registradores da CPU nos registradores do processo · recupera as informações do BCP do novo processo e grava os valores dos registradores do novo processo nos registradores da CPU · começa a execução do novo processo Entre threads, não existe uma troca de contexto propriamente dita. O SO salva as informações específicas da thread e recupera as informações específicas da outra thread que deverá entrar em execução. O contexto do processo continua o mesmo, ocorrendo apenas a troca entre contador de programa, pilha e registradores da thread.

1) processo que estava executando é bloqueado pelo SO (entrada de dados)

2) processo que estava executando é suspenso pelo SO (troca entre processos)

3) processo suspenso entra novamente em execução (processo escalonado)

4) processo bloqueado fica pronto para ser executado (liberação de entrada de dados)

Runnable: pronta para executar Active: executando Sleeping: dormindo (esperando recurso) Stopped: parada Zombie: finalizada

As system calls servem para que o usuário possa interagir com as funções do sistema operacional. A chamada a uma system call é semelhante à chamada de uma função em um programa, com a diferença que as funções realizadas através da chamada de uma system call são realizadas (e implementadas) pelo kernel do sistema operacional (interrupção de software).

· Gerenciar as áreas de memória que estão sendo usadas e as que estão livres

· Alocar e desalocar memória para os processos

· Alocar espaço em disco quando a memória principal não for suficiente (gerenciar swapping)

Vantagens:

· criar threads é mais rápido e mais barato

· Não é necessária a troca de todo o contexto para trocar o thread que está em execução por outro que está esperando para ser executado

· Pode fornecer respostas mais rápidas

· Recursos podem ser compartilhados

Desvantagem: necessidade de sincronização

Beneficiada: aplicações sem dependência de dados

Não beneficiada: aplicações com dependência de dados

Preemptivo: um processo em execução pode ser suspenso para dar lugar à execução de outro processo que está esperando para ser executado

Não preemptivo: uma vez alocada a CPU a um processo, esse é executado até o fim ou quando o processo aguarda por algum recurso bloqueado.

Linux: Round Robin com prioridade Solaris:

Uma pequena unidade de tempo, denominada timeslice ou quantum, é definida. Todos os processos são armazenados em uma fila circular. O escalonador da CPU percorre a fila, alocando a CPU para cada processo durante um quantum. Mais precisamente, o escalonador retira o primeiro processo da fila e procede à sua execução. Se o processo não termina após um quantum, ocorre uma preempção, e o processo é inserido no fim da fila. Se o processo termina antes de um quantum, a CPU é liberada para a execução de novos processos. Em ambos os casos, após a liberação da CPU, um novo processo é escolhido na fila. Novos processos são inseridos no fim da fila. Quando um processo é retirado da fila para a CPU, ocorre uma troca de contexto, o que resulta em um tempo adicional na execução do processo.

Situação na qual vários threads acessam e manipulam os mesmos dados de forma concorrente. Quando ocorre race condition, o resultado da execução do processo depende da ordem específica em que o acesso aos dados acontece.

Deadlock é a situação na qual dois ou mais processos competem por um recurso sendo que, em um dado instante, um processo solicita um recurso que não está disponível e fica bloqueado esperando pela liberação do recurso. Pode ser que, por algum motivo, o recurso nunca seja liberado, fazendo com que o processo que o está esperando nunca seja desbloqueado e conseqüentemente não termine sua execução.

As condições seguintes devem ser satisfeitas num dado instante para que o deadlock ocorra: · Exclusão mútua: apenas um processo por vez pode utilizar um dado recurso; · Uso e espera: pelo menos um processo utilizando um recurso e esperando pela liberação de outro · Inexistência de preempção: um recurso só pode ser liberado pelo processo que o alocou · Espera circular: um conjunto de processos espera por recursos alocados por outros processos de forma circular (um depende do outro imediatamente anterior). Deadlocks são evitados quando pelo menos uma das quatro condições não é verdade. Através da sincronização, o deadlock é evitado.

Busy wait é quando um conjunto de instruções é executado infinitamente até que uma dada condição seja satisfeita, por exemplo, enquanto um thread está executando a seção crítica, os outros que tentarem acessa-la deverão executar um laço até que a seção crítica seja liberada. Os algoritmos que empregam busy wait são ineficientes porque consomem tempo de CPU enquanto outros threads poderiam ser executados. No bloqueio, o thread que chega à seção crítica, que está sendo utilizada por outro thread, é colocado em estado de espera e só volta à execução quando a região for liberada e ele for escalonado para ser executado.

Exclusão mútua: proíbe que mais de um thread acesse o dado compartilhado ao mesmo tempo vantagem: resolve o problema de vários threads alterarem o valor de um dado de forma desordenada desvantagem: não garante a seqüência das instruções (sincronização) Variáveis de condição: bloqueia um thread até que uma dada condição seja verdadeira Vantagem: resolve o problema de sincronização Desvantagem: sinais podem ser perdidos e quando é necessário controlar mais de uma condição, a implementação fica complicada Semáforos: um thread espera por um semáforo para realizar determinada região crítica (atomicidade na adição, remoção do recurso e bloqueio do thread). Vantagem: não perde sinais e permite controlar grande variedade de recursos e condições de forma mais simplificada. Desvantagem:

Atomicidade de uma transação significa que uma dado operação ou é executada até o seu fim, ou não é executada, ou seja, uma transação atômica garante a execução da operação por inteira. Se as operações de wait e signal não forem atômicas, ou seja, não garantirem a execução do restante do código do thread, o programa não funcionará porque um thread ficará esperando pelo sinal que não vai ser enviado pelo outro thread.