Gerência do Processador

Funções

Com o surgimento dos sistemas multiprogramáveis, onde múltiplos processos poderiam permanecer na memória e disputar o uso de um único processador, a gerência do processador tornou-se uma das atividades mais importantes em um sistema operacional.

A partir do momento em que vários processos podem estar no estado de pronto, devem ser estabelecidos critérios para definir qual processo será escolhido para fazer uso do processador. Tais critérios compõem a política de escalonamento, que é a base da gerência do processador e da multiprogramação em um sistema operacional.

Dentre as funções da gerência do processador, podemos citar: 

• Manter o processador ocupado a maior parte do tempo;
• Balancear o uso da CPU entre processos;
• Privilegiar a execução de aplicações críticas;
• Maximizar o throughput e;
• Oferecer tempos de resposta razoáveis aos usuários interativos.

Cada sistema operacional possui sua política de escalonamento adequada ao seu propósito e às suas características. Sistemas de tempo compartilhado, por exemplo, possuem requisitos de escalonamento distintos dos sistemas de tempo real.

Critérios de escalonamento

-          Utilização do processador: corresponde a uma taxa de utilização, que na maioria dos sistemas varia entre 30 e 90%. Uma utilização abaixo dos 30% indicaria um sistema ocioso, com carga de processamento baixa, enquanto uma taxa de utilização acima dos 90% pode indicar um sistema bastante carregado, próximo da sua capacidade máxima (em alguns casos tal situação pode levar a um crash – travamento do sistema).

-          Throughput: é o número de processos executados em um determinado intervalo de tempo. Quanto maior o throughput, maior o número de tarefas executadas em função do tempo. A maximização do throughput é desejada na maioria dos sistemas.

-      Tempo de Processador: é o tempo que um processo leva no estado de execução, durante seu processamento. As políticas de escalonamento não interferem neste parâmetro, sendo este tempo função apenas do código executável e da entrada/saída de dados.

-       Tempo de Espera (pela CPU): é todo o tempo que o processo permanece na fila de pronto, aguardando a liberação da CPU para ser executado. A redução deste tempo de espera é desejada pela maioria das políticas de escalonamento.

-          Tempo de Turnaround: é o tempo total que o processo permaneceu no sistema, desde sua criação até o momento em que é encerrado. São contados os tempos de alocação de memória, espera na fila de pronto e  interrupção (E/S).

-          Tempo de Resposta: é o tempo decorrido entre uma requisição ao sistema e o instante em que a resposta começa a ser exibida. Em sistemas interativos, como aplicações on-line ou acesso à Web, os tempos de resposta devem ser da ordem de apenas poucos segundos.

Escalonamentos Não-Preemptivos e Preemptivos

Escalonamentos do tipo não-preemptivos são aqueles onde o sistema operacional não pode interromper o processo em execução para retirá-lo da CPU. Assim sendo, se nenhum evento externo ocorresse durante a execução do processo, este permanecia na CPU até terminar ou então alguma instrução do próprio programa o desviasse para o estado de espera (operação de E/S).

Já os escalonamentos preemptivos são caracterizados pela possibilidade de o sistema operacional interromper o processo em execução para retirá-lo da CPU e dar lugar a outro. Neste caso o processo retirado da CPU volta ao estado de pronto, onde permanece aguardando nova oportunidade de ocupar a CPU. Com o uso da preempção, é possível ao sistema priorizar a execução de  processos, como no caso de aplicações em tempo real. Outro benefício é a possibilidade de implementar políticas de escalonamento que compartilhem o processador de uma maneira mais uniforme, balanceando o uso da CPU entre os processos.

São escalonamentos não-preemptivos:

-          FIFO: o processo que chegar primeiro à fila de pronto é selecionado para execução, e permanece utilizando o processador até terminar sua execução ou ser interrompido por E/S. Neste caso, o próximo processo da fila de pronto é selecionado para execução. Todo processo que chega à fila de pronto entra no final desta fila, conservando a ordem de chegada na fila, até ser escalonado novamente. Apesar de simples, este escalonamento apresenta algumas deficiências, principalmente no que diz respeito à dificuldade de se prever o início da execução de um processo, já que a ordem de chegada á fila de pronto deve ser observada à risca. Outro problema é quanto aos tipos de processo, onde os CPU-bound levam vantagem no uso do processador em relação aos do tipo I/O-bound, pois o sistema não trata este tipo de diferença. O escalonamento FIFO foi inicialmente implementado em sistemas monoprogramáveis, sendo ineficiente se aplicado em sistemas interativos de tempo compartilhado.

-          SJF (Shortest Job First): este  escalonamento seleciona o processo que tiver o menor tempo de processador ainda por executar. Desta forma, o processo que estiver na fila de pronto com menor necessidade de tempo de CPU para terminar o seu processamento será o escolhido para ocupar a CPU. Funciona com um parâmetro passado ao sistema via contexto de software, onde o tempo estimado para o processo é informado baseando-se em estatísticas de execuções anteriores.

Como exemplo, vamos utilizar os mesmos processos executados no escalonamento FIFO acima, com seus respectivos tempos de execução em u.t. (unidades de tempo): processo A com 10 u.t., processo B com 8 u.t, e o processo C com 9 u.t. Como neste escalonamento o que importa é o tempo de execução,  a nova ordem de escalonamento para utilização da CPU será B, C e A.

-          Cooperativo: este escalonamento busca aumentar o grau de concorrência no processador. Neste caso, um processo em execução pode voluntariamente liberar o processador retornando à fila de pronto, possibilitando que um novo processo seja escalonado, permitindo melhor  distribuição do tempo do processador. A liberação da CPU é uma tarefa exclusiva do programa em execução, que de maneira cooperativa libera o processador para um outro processo. Neste mecanismo, o processo em execução verifica periodicamente uma fila de mensagens para saber se existem outros processos na fila de pronto. Porém, como a interrupção do processo não depende do sistema operacional, situações indesejáveis podem ocorrer, como por exemplo, se um programa em execução não verificar a fila de mensagens, os demais programas não terão chance de executar enquanto a CPU não for liberada. As primeiras versões do Windows chegaram a utilizar este tipo de escalonamento.

-          Circular: é um tipo de escalonamento projetado especialmente para sistemas em tempo compartilhado. É muito semelhante ao FIFO (obedece a ordem de chegada á fila de PRONTO), mas quando um processo passa para o estado de execução há um limite de tempo para o uso contínuo do processador, chamado fatia de tempo (time-slice) ou quantum. Assim, toda vez que um processo é selecionado para execução uma nova fatia de tempo lhe é concedida. Caso esta fatia de tempo expire, o sistema operacional interrompe o processo, salva seu contexto e o direciona para a fila de PRONTO. Este mecanismo é conhecido como preempção por tempo. A principal vantagem deste escalonamento é não permitir que um processo monopolize a CPU. Outrossim, uma desvantagem é que os processos CPU-bound são beneficiados no uso do processador em relação aos processos I/O-bound, pois tendem a utilizar totalmente a fatia de tempo recebida. A figura a seguir mostra o escalonamento circular com 3 processos, onde a fatia de tempo é igual a 2 u.t. No exemplo não estão sendo levados em consideração tempos de troca de contexto entre os processos, nem o tempo perdido em operações de E/S. Os processos A, B e C, gastam 10 u.t, 6 u.t e 3 u.t., respectivamente.

 

São escalonamentos preemptivos:

-          Circular: é um tipo de escalonamento projetado especialmente para sistemas em tempo compartilhado. É muito semelhante ao FIFO (obedece a ordem de chegada á fila de PRONTO), mas quando um processo passa para o estado de execução há um limite de tempo para o uso contínuo do processador, chamado fatia de tempo (time-slice) ou quantum. Assim, toda vez que um processo é selecionado para execução uma nova fatia de tempo lhe é concedida. Caso esta fatia de tempo expire, o sistema operacional interrompe o processo, salva seu contexto e o direciona para a fila de PRONTO. Este mecanismo é conhecido como preempção por tempo. A principal vantagem deste escalonamento é não permitir que um processo monopolize a CPU. Outrossim, uma desvantagem é que os processos CPU-bound são beneficiados no uso do processador em relação aos processos I/O-bound, pois tendem a utilizar totalmente a fatia de tempo recebida. A figura a seguir mostra o escalonamento circular com 3 processos, onde a fatia de tempo é igual a 2 u.t. No exemplo não estão sendo levados em consideração tempos de troca de contexto entre os processos, nem o tempo perdido em operações de E/S. Os processos A, B e C, gastam 10 u.t, 6 u.t e 3 u.t., respectivamente.

-          Por Prioridades: funciona com base num valor associado a cada processo, denominado prioridade de execução. O processo com maior prioridade na fila de PRONTO é sempre o escolhido para ocupar o processador, sendo os processos com prioridades iguais escalonados pelo critério FIFO. Neste escalonamento o conceito da fatia de tempo não existe. Como conseqüência disto, um processo em execução não pode sofrer preempção por tempo. Neste escalonamento a perda do uso do processador somente ocorrerá no caso de uma mudança voluntária para o estado de espera (interrupção por E/S), ou quando um outro processo de prioridade maior passa (ou chega) para o estado de pronto. Neste caso o sistema operacional interrompe o processo em execução, salva seu contexto e o coloca na fila de pronto, dando lugar na CPU ao processo prioritário. Este mecanismo é chamado de preempção por prioridade. A figura a seguir mostra a execução dos processos A, B e C, com tempos de execução de 10, 4 e 3 u.t. respectivamente, e valores de prioridades de 2, 1 e 3, também respectivamente. Na maioria dos sistemas, valores menores correspondem à MAIOR prioridade. Assim, a ordem de execução será invertida para B, A e C.

          A prioridade de execução faz parte do contexto de software do processo, e pode ser estática (quando não pode ser alterada durante a existência do processo) ou dinâmica (quando pode ser alterada durante a existência do processo). Este escalonamento é muito usado em sistemas de tempo real, com aplicações de controle de processos, controle de tráfego (sinais de trânsito, de trens/metrô, aéreo), robótica, entre outros.

-          Escalonamento Circular com Prioridades: implementa o conceito de fatia de tempo e de prioridade de execução  associada a cada processo. Neste escalonamento, um processo permanece no estado de execução até que termine seu processamento, ou voluntariamente passe para o estado de espera (interrupção por E/S), ou sofra uma preempção por tempo ou prioridade. A principal vantagem deste escalonamento é permitir um melhor balanceamento no uso do processador, com a possibilidade de diferenciar o grau de importância dos processos através da prioridade (o Windows utiliza este escalonamento).

-          Por Múltiplas Filas: Este escalonamento implementa várias filas de pronto, cada uma com prioridade específica. Os processos são associados às filas de acordo com características próprias, como importância da aplicação, tipo de processamento ou área de memória necessária. Assim, não é o processo que detém a prioridade, mas sim a fila. O processo em execução sofre preempção caso um outro processo entre em uma fila de maior prioridade. O sistema operacional só pode escalonar processos de uma fila quando todas as outras filas de maior prioridade estejam vazias. Os processos sempre voltam para a mesma fila de onde saíram.

-          Por Múltiplas Filas com Realimentação: semelhante ao anterior, porém permitindo ao processo voltar para uma outra fila de maior ou menor prioridade, de acordo com seu comportamento durante o processamento. O sistema operacional identifica dinamicamente o comportamento de cada processo e o redireciona para a fila mais conveniente ao longo de seu processamento. É um algoritmo generalista, podendo ser implementado na maioria dos sistemas operacionais.

Tipos de processos

Além dos processos do usuário, a CPU também executa processos do sistema. São aqueles que oferecem os serviços do sistema operacional aos usuários, como criação/eliminação de processos, tratamento de interrupção e todos aqueles correspondentes às funções do sistema já estudadas. Estes executam sempre, com certa prioridade, concorrendo com os processos do usuário.

Os processos em execução, do usuário, podem assumir dois tipos diferentes, de acordo com suas características de uso de CPU e periféricos:

-          Processo CPU-bound: é aquele processo que utiliza muito a CPU. Ele ganha uma fatia de tempo e a utiliza por inteiro, sem desperdiçar nenhum tempo. É o caso de programas científicos, de cálculo numérico, estatística, matemática, e também na área de simulação. Normalmente fazem pouca ou nenhuma entrada de dados, e muito processamento.

-          Processo I/O-bound: é o tipo de processo que utiliza muito mais E/S do que CPU. Aplicações em Banco de Dados, onde se faz consultas e atualizações constantes em arquivos em disco são um bom exemplo deste tipo de processo. De acordo com essas características, podemos dizer que este tipo de processo permanece mais tempo em espera (tratando interrupções) do que propriamente em execução, ocupando a CPU por períodos mínimos de tempo.

Mudanças de estado do processo

Um processo muda de estado diversas vezes durante sua permanência no sistema, devido aos eventos ocorridos durante sua execução. São mudanças possíveis:

-          Criaçãoà Pronto: o processo foi criado, tem seus recursos alocados, e está apto a disputar o uso da CPU.

-          Pronto à Execução: o processo é o primeiro da fila de pronto e a CPU fica disponível. Neste momento o processo passa a ocupar a CPU, permanecendo em execução até que seja interrompido ou termine sua execução.

-          Execução à Pronto: o processo foi interrompido por fatia de tempo ou por prioridade. Ainda precisa de mais tempo na CPU para terminar sua execução, não tem nenhuma intervenção pendente, por isso volta à fila de pronto para disputar novamente o uso da CPU.

-          Execução à Espera: esta transição acontece quando o processo foi interrompido por E/S. Significa que deve permanecer no estado de espera até que a interrupção seja tratada pelo sistema. Neste estado o processo fica impedido de disputar o uso da CPU.

-          Espera à Pronto: Após o término do tratamento da interrupção, o processo volta à fila de pronto para disputar novamente o uso da CPU.

-          Execução à Saída: o processo terminou, e não mais disputará o uso da CPU.

A seguir, a figura mostra as mudanças possíveis de estado de um processo.

 

  

Estados de um processo

Estados do processo

Num sistema multiprogramável, um processo não deve alocar a CPU com exclusividade, de forma que possa existir um compartilhamento no uso do processador. Os processos passam por diferentes estados ao longo do processamento, em função de eventos gerados pelo sistema operacional, pelo hardware, ou pelo próprio programa. São estados possíveis de um processo:

-          Criação: neste estado o processo está sendo alocado na memória, sendo criado no sistema. Todos os recursos necessários à execução do processo são reservados durante a passagem do processo por este estado, o que acontece uma única vez. Vários processos podem estar neste estado, ao mesmo tempo.

-          Pronto: é o estado onde os processos, depois de criados ou quando retornam do tratamento de uma interrupção, permanecem aguardando a liberação da CPU para que possam iniciar ou continuar seu processamento. É como se fosse uma fila, gerenciada pelo sistema operacional, que se incumbe de organizar os processos de acordo com as informações contidas no contexto de software (identificação, quotas e privilégios). Vários processos podem estar neste estado, ao mesmo tempo.

-          Execução: é onde o processo efetivamente utiliza a CPU. Ele permanece no processador até que seja interrompido ou termine sua execução. Neste estado, somente um processo pode permanecer de cada vez, já que existe apenas um processador.

-          Espera: neste estado estão todos os processos que sofreram algum tipo de interrupção de E/S, onde permanecem até que a intervenção seja resolvida. Vários processos podem estar neste estado, ao mesmo tempo.

-          Saída: é o estado final do processo, quando este termina seu processamento. Vários processos podem estar neste estado, ao mesmo tempo.

Estrutura básica de um Kernel Linux

O Kernel Linux é um Kernel monolítico, ou seja, todas as suas funções (acesso e gravação nos filesystems (sistemas de arquivos), operações de entrada e saída, gerenciamento de memória, e agendamento de processos) são realizadas no espaço do próprio Kernel, ou seja, são todas realizadas em um único bloco com todas as funcionalidades básicas carregadas na memória.

A grande vantagem do Kernel Linux é que muitas funções podem ser compiladas e executadas como módulos (LKM – Loadable Kernel Modules ou Módulos Carregáveis do Kernel), que são bibliotecas compiladas separadamente da parte principal do Kernel e podem ser carregadas e descarregadas pelo sistema mesmo com o Kernel já estando em execução (pra quem não sabe, compilar um programa ou módulo é basicamente “fazer com que um compilador o reescreva, já interpretado”, para transformar as instruções de alto nível  (linguagem mais próxima da linguagem humana) nele contidas em instruções de baixo nível (linguagem “de máquina”), para que não ocorram, durante a execução do mesmo, perdas de tempo com interpretação de instruções).

Outra característica fantástica do Kernel Linux é sua portabilidade, que permite que o mesmo seja utilizado em sistemas mínimalistas (como celulares e palmtops) até sistemas de enorme porte, como densos mainframes. Por outro lado, temos também a enorme portabilidade no sentido do Kernel ser extremamente compatível com uma imensa variedade de fontes que podem ser compiladas e utilizadas em Linux.

Como funciona o Kernel?

1- Os filesystems (sistemas de arquivos)

Filesystem, ou sistema de arquivos, é o sistema utilizado pelo Kernel Linux para organizar, acessar e escrever os arquivos nos discos ou mídia de armazenamento disponível no sistema. Ou seja, é um artifício usado pelo Kernel para controlar a gravação e leitura dos dados (no seu disco rígido, por exemplo).

Existem vários tipos de filesystems, sendo que os mais conhecidos para GNU/Linux são:

- os baseados em discos -> Ext2 , Ext3 , ReiserFS , XFS , JFS  e ISO 9660 ;

- os baseados em rede -> NFS , SMBfs , Coda  e AFS ;

- os filesystems especiais -> Utilizados em diretórios como o /proc, ramfs e devfs.

Cada filesystem tem suas especificações, tais como tamanho de blocos (ou espaços delimitados destinados ao recebimento dos arquivos) e técnicas especiais de recuperação em caso de falhas.

- Filesystems “jornalados” ou journaling filesystems, são filesystems que utilizam técnicas de recuperações em caso de falhas (como desligamentos abruptos, queda de energia e outros tipos de desastre de sistemas de arquivos). A expressão “journal” está ligada à ideia de se manter um log ou registro de eventos realizados no filesystem.

Os sistemas de arquivos com journaling mais utilizados atualmente em sistemas operacionais GNU/Linux são: 

• ReiserFS  (criado por Hans Reiser );
• Ext3  (criado por Stephen Tweedie); 
• XFS (criado pela Silicon Graphics ) e 
• JFS  (criado pela IBM ). 

O sistema GNU/Linux atualmente também é capaz de ler e escrever no sistema de arquivos NTFS (sistema de arquivos proprietário da empresa microsoft).

2 – Operações I/O ou E/S (In/Out ou Entrada/Saída)

São as operações de comunicação do Kernel Linux com os dispositivos de hardware da máquina. As operações de entrada e saída realizadas pelo Kernel Linux são implementadas através dos device drivers, ou seja, para cada dispositivo de hardware da máquina, existe um device do Kernel (arquivo que serve de ligação com os dispositivos de hardware, criado pelo Kernel no diretório /dev do filesystem (sistema de arquivos)).

O Kernel Linux realiza todas as operações de E/S com uma sequëncia de bytes, sem qualquer conceito de registro ou métodos de acesso. Dessa forma, ocorre uma comunicação mais direta com os dispositivos de hardware, de maneira uniforme. O Kernel pode acessar e escrever nos arquivos de ligação do diretório /dev (ou devices do Kernel) da mesma forma que ocorre em qualquer outro arquivo do filesystem, utilizando chamadas do sistema (system calls) de leitura e gravação.

O Kernel Linux trabalha com dois tipos de operações de E/S: orientadas a blocos e orientadas a caracter. As operações orientadas a bloco são geralmente utilizadas em dispositivos com uma taxa alta de transferência de dados (como por exemplo discos rígidos) fazendo com que seja reduzido o número de transferências necessárias entre o device do Kernel e a memória, já que em cada tranferência de dados são enviadas várias informações simultaneamente em blocos (agrupamentos). Já os dispositivos de hardware mais lentos, ou que demandam uma transferência menor de dados, são orientados a caracter, ou seja, a transferência entre o dispositivo e a memória são realizadas caracter a caracter.

3- Gerenciamento de memória

Entenda que quando executamos aplicativos ou funções do sistema operacional, o processador da máquina executa trocas dinâmicas com a memória principal do sistema (memória RAM). Isto ocorre pois o processador precisa armazenar as informações que recebeu para processá-las aos poucos de acordo com sua capacidade. O subsistema de gerenciamento de memória do Kernel Linux, preocupa-se especialmente com alguns fatores responsáveis pelo correto e eficaz gerenciamento dessas trocas dinâmicas.

Os principais aspectos do gerenciamento de memória são:

- Utilização de memória e swapping: O Kernel Linux sempre utiliza a maior quantidade de memória RAM possível, já que quando executamos um programa qualquer, tornando-o um processo do sistema, ele armazena temporariamente na memória RAM os dados necessários à sua execução, e esses dados não são apagados imediatamente após o encerramento de sua execução. Eles permanecem carregados na memória o máximo de tempo possível, pois caso o mesmo processo seja executado novamente em breve, os dados ainda estarão lá disponíveis, agilizando muito a execução. Essa técnica de manter os dados de programas executados na memória RAM chama-se Buffer Cache, e é utilizada para os dados que são utilizados pelos device drivers (drivers de dispositivos de hardware de que falamos acima em operações E/S). O Buffer Cache só é apagado parcialmente ou totalmente da memória RAM quando não há mais espaço suficiente para carregar um novo programa, e os dados escolhidos a serem apagados são aqueles que estão há mais tempo sem serem acessados, o que mostra ao Kernel que eles provavelmente não serão mais utilizados tão breve. Esse método de escolha é chamado de swapping, que utiliza um conceito de “envelhecimento” de informações conforme as mesmas não são utilizadas, e “rejuvenecimento” de informações conforme as mesmas são acessadas (não confundir swapping com memória virtual ou swap).

- Proteção: O Kernel Linux divide e separa os processos carregados na memória RAM da máquina como processos do kernel e processos do usuário.

- Mapeamento de memória: Os processos em execução no sistema são divididos em páginas e somente algumas dessas páginas estão realmente na memória física do computador. Outras delas são “endereços virtuais” que agilizam o processo de acesso da memória. A utilização de endereços virtuais com endereços reais (físicos) de memória é chamada de mapeamento de memória. Todos os processos tem referências em uma estrutura de dados chamada pelo Kernel Linux de “mm_struct”. Esta estrutura contém informações sobre o que está sendo executado no momento e possui apontamentos para uma outra estrutura de dados chamada “vm_area_structure”, que contém “o endereço” de todos os PFN (Page Frame Numbers – que podemos entender de maneira menos técnica como o “endereço” ou localização exata de onde estão realmente as informações na memória do computador).

- Alocação: O Kernel Linux utiliza o algoritmo Buddy (Companheiro – nome pelo qual é conhecido o algoritmo de alocação) para alocar e desalocar páginas de memória utilizando blocos de páginas. O gerenciamento de memória do Kernel aloca e desaloca páginas de memória com extremo dinamismo, causando assim uma fragmentação de memória, que é resolvida pelo Kernel com um processo de desfragmentação que junta espaços preenchidos de memória que são categoricamente semelhantes.

Memória Cache: É utilizada para otimizar e agilizar o acesso a informações. Exemplos de Cache utilizadas pelo Kernel Linux: Buffer Cache (vimos acima quando falei de operações E/S – são blocos de tamanho fixo usados por device drivers que agilizam o acesso a informações que já estejam nesse buffer, tornando desnecessário o acesso direto ao dispositivo de hardware), o Page Cache(usado para tornar mais rápido o acesso a vários tipos de informação no disco), e o Swap Cache(que faz com que apenas páginas de memória modificadas sejam salvas na memória virtual física (que veremos abaixo) sendo que as páginas de memória inalteradas com seu acesso podem ser descartadas sem a necessidade de gravá-las fisicamente).

Memória Virtual: Memória virtual ou memória SWAP é um recurso utilizado pelo Kernel Linux que consiste em reservar uma parte da memória secundária da máquina (o disco rígido), especificada pelo usuário, para ser uma extensão da memória primária (memória RAM). O conceito de memória virtual está, ao contrário do que muitos pensam, ligado ao produto final da junção entre a memória primária e o espaço reservado da memória secundária. Ou seja… A memória virtual = Memória RAM + Memória SWAP. O processador transfere os dados do processo que está executando diretamente para a memória RAM (primária). Quando surge a necessidade de esvaziamento de parte da RAM para executar outro processo (e surge mesmo, pois lembre-se que o Kernel Linux utiliza sempre o máximo de memória possível devido ao Buffer Cache, para agilizar os processos), alguns processos existentes, mais envelhecidos (pelo swapping) que estiverem esperando para continuar sua execução, são transferidos para a o disco rígido, para a parte reservada à memória SWAP. Para que esse recurso possa ser utilizado, uma partição deve ser criada no disco durante a instalação do sistema operacional e especificada (reservada) como partição SWAP. O tamanho ideal para uma partição swap é um assunto que merece atenção exclusiva, e por isso, falarei sobre isso e sobre planejamento de particionamento num próximo post.

4- Agendamento de processos

Primeiramente vamos esclarecer de uma ver por todas o que é processo. Processo é uma instância de um programa em execução. Todo processo tem um pai (ou processo criador) e um número único atribuído pelo Kernel no momento de sua execução, que o identifica no sistema… o PID(Process Identifier). Para fazer um planejamento e compartilhamento adequado do tempo do processador, o Kernel Linux usa um sistema de 2 tipos de classificação, que avalia cada processo e lhe atribui qualidades que permitem que seja determinada uma prioridade de execução para cada processo avaliado. Os processos são classificados pelo Kernel quanto a sua responsividade (ou seja, se o processo responde em tempo real, interativo ou em segundo plano) e quanto a suaintensidade de atividade (ou seja, se o processo utiliza muito tempo de processador (CPU-Bound ou Limite de CPU) e se faz muitas operações de E/S (I/O-Bound ou Limite de Entrada e Saída)). Essas duas classificações são relativamente independentes, ou seja, um processo pode, por exemplo, ter uma baixa responsividade (como um daemon por exemplo, executado em segundo plano) e ao mesmo tempo ter uma grande intensidade de atividade (ou seja, ter um grande consumo de operações de E/S)… Podemos citar como o exemplo o caso do Servidor Web Apache2 servindo um banco de dados MySQL. Avaliadas essas classificações, o Kernel Linux utiliza seu sistema de prioridades e organiza os processos. A identificação da prioridade de um processo pode serestática ou dinâmica, e varia de 1 (maior prioridade) a 139 (menor prioridade), sendo que os números de 1 a 99 são atribuídos a processos executados em tempo real, e de 100 a 139 são atribuidos a processos tradicionais (processos interativos ou processos executados em segundo plano).

Os processos executados em tempo real são classificados como FIFO (First-In, First-Out) ou RR (Round-Robin), e eles somente passam a ser excluídos do processamento atual nos casos de: fim de sua execução; para ser substituído por um processo que possua prioridade ainda maior; executar uma operação de bloqueio; espontaneamente pelo próprio processo; quando o processo é RR (Round-Robing) e esgotou seu quantum de processamento.

Um processo tradicional (processos interativos e os executados em segundo plano) tem inicialmente uma prioridade estática atribuída (normalmente 120) que determina o seu quantum de processamento, mas pode ter uma prioridade dinâmica, que é o valor analisado pelo agendador de processos do Kernel quando percorrer a lista de processos para determinar de qual processo é a vez de utilizar o processador. A prioridade dinâmica pode alterar o valor da prioridade estática em + ou – 5 pontos dependendo do passado do processo (lembre-se que quando menor a pontuação, maior a prioridade do processo). Ou seja, o passado do processo irá beneficiá-lo caso o mesmo tenha ficado muito tempo esperando por sua execução fora do processador (sleep time). Caso o sleep time seja pequeno, o processo irá ser penalizado, ou seja, seu número de prioridade irá aumentar, tornando sua prioridade de execução menor.

Fonte: aptscience