Um processo pode ser descrito como parte de um programa que está aparentemente rodando. Este aparente existe somente pelo fato de que determinado processo pode entrar e sair diversas vezes do processador em um único segundo, e em um determinado momento ele pode não estar no processador e mesmo assim aparentemente estar rodando.
Como qualquer sistema de compartilhamento de tempo o Linux consegue dar a impressão de execução simultânea dos processos, separando um espaço bastante curto de tempo para cada um deles. Para ter sucesso nesta tarefa ele segue uma serie de regras que não desperdiça tempo de hardware com operações desnecessárias e consegue escolher qual processo deve ser executado naquele exato momento.
O que decide essa escolha no kernel é o escalonador de processos, que em grande parte é responsável pela produtividade e eficiência do sistema. Mais do que um simples mecanismo de divisão de tempo, ele é responsável por uma política de tratamento dos processos que permite os melhores resultados possíveis.
Durante a fase de inicialização do Linux a função ``start_kernel'' é responsável por criar um thread, este é o processo de número zero, o primeiro e o ascendente de todos os outros processos. Após inicializar toda a estrutura de dados para este processo esta mesma função é responsável por chamar a função ``init'' que por sua vez utiliza a chamada de sistema ``execve'' para rodar o executável init, que será o processo número 1, mais conhecido como init.
Podemos chamar de Deus e pai de todos os outros processos, é o segundo processo a ser criado e um dos últimos a morrer. Seus filhos, vivem como nós seres humanos, eles nascem, se desenvolvem, tem uma vida mais ou menos produtiva, podem ter inúmeros filhos em poucos segundos e eventualmente morrem.
Existem alguns outros processos que também são criados pelo kernel durante a fase de inicialização e destruídos assim que o sistema desliga. Outros são criados sob demanda, assim que surge a necessidade deles são carregados.
Uma das coisas que o escalonador precisa ter ciência é em qual estado está cada processo, na estrutura que armazena os dados de cada processo temos um array de possíveis estados onde apenas uma das opções abaixo estará ativa.
Por padrão o Linux limita os recursos que cada processo pode ter. Isto é, quanto de recursos do sistema ele pode utilizar. Isso é uma proteção para que caso o usuário faça algo errado, não prejudique a estabilidade do sistema. Esses limites são:
Os processos do Linux são preemptivos, isso significa que quando um processo entra no estado TASK_RUNNING o kernel vai checar se existe alguma prioridade maior do que o processo corrente. Caso exista, o processo corrente é interrompido e o que tem prioridade maior começa a rodar.
Imagine a seguinte situação onde o Sr. Gênio dos Teclados utiliza apenas dois processos. O editor de textos Emacs para escrever o seu programa e ao mesmo tempo o gcc para compilar a versão mais recente do programa Pogobol Light. Por ser um programa interativo o editor de textos tem uma prioridade maior do que o compilador, mesmo assim ele ainda é suspenso diversas vezes para que o compilador possa rodar também. O Sr. Gênio dos Teclados digita algumas palavras e imediatamente após cada tecla digitada o kernel suspende a execução do compilador para poder processar o Emacs e assim o texto digitado aparecer na tela, isso acontece tão rápido que torna-se imperceptível, então o Emacs é suspenso novamente para que o gcc possa voltar a executar. Neste caso, quando dizemos que um processo foi suspenso, significa que ele continua com o estado TASK_RUNNING, porém não mais utilizando o CPU.
A prioridade de um processo no Linux está em constante alteração, o escalonador se mantém informado sobre o que os processos estão fazendo e assim torna-se possível ajustar a prioridade. Dessa maneira os processos que ficaram proibidos de utilizar o CPU por um longo intervalo de tempo, tem sua prioridade incrementada automaticamente, contrariamente os processos que passaram um longo período dentro do CPU são penalizados tendo sua prioridade decrementada.
Quando tocamos no assunto escalonamento é importante notar que os processos são classificados como da Forma E/S e Forma CPU. O primeiro faz uso extenso dos recursos de entrada e saída, isso significa que grande parte do seu tempo é utilizado no aguardo do conclusão das operações de Entrada e Saída, já o segundo são processos que necessitam de um longo tempo dentro do CPU.
Uma classificação alternativa define três classes de processos:
O algoritmo de escalonamento do Linux funciona dividindo o tempo do CPU em fatias. Em uma única fatia cada processo tem um tempo especifico de duração que é computada assim que essa fatia inicia. Geralmente processos diferentes tem tempos de execução diferentes. Quando o tempo de execução de um processo termina ele é retirado do CPU e outro processo que está rodando é colocado no seu lugar. Uma fatia termina quando todos os processos esgotaram seu tempo reservado de execução, assim o escalonador é responsável por calcular o tempo de execução para todos os processos e uma nova fatia inicia.
Para o Linux escolher qual processo deve rodar ele precisar escolher qual tem a prioridade maior, existem dois tipos de prioridade:
Se existir um processo com prioridade estática no estado TASK_RUNNING nenhum processo dinâmico irá rodar até que ele pare de executar.
This document was generated using the LaTeX2HTML translator Version 2002-2-1 (1.70)
Copyright © 1993, 1994, 1995, 1996,
Nikos Drakos,
Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999,
Ross Moore,
Mathematics Department, Macquarie University, Sydney.
The command line arguments were:
latex2html -split 0 -no_subdir -no_navigation gerenciamento_de_processos_no_linux.tex
The translation was initiated by Marcelo Toledo on 2005-04-26