Atps De S.o

GERENCIAMENTO DE PROCESSOS E THREAD

Processos são uma das mais antigas e importantes abstrações que o sistema operacional oferece. Eles mantem a capacidade de operações (PSEUDO) concorrentes, mesmo quando há apenas uma CPU disponível. Eles transformam uma única CPU em múltiplas CPUs virtuais.

Thread, ou linha de execução em português, é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas simultaneamente. Nos sistemas operacionais tradicionais, cada processo tem um espaço de endereçamento, e um único thread de controle. Isso e quase uma definição de processos, contudo, frequentemente há situações em que e desejável ter múltiplos thread de controle no mesmo espaço de endereçamento de endereçamento executando em quase-paralelo, como se eles fossem processos separados.

POLITICA DE GERENCIAMENTO DE PROCESSADOR

Esse recurso é útil quando aplicativos complexos têm muitas tarefas que podem ser executadas ao mesmo tempo. Quando um sistema operacional executa uma instância de um aplicativo, cria uma unidade denominada processo para gerenciar a instância. O processo tem um thread de execução. Tal processo é a série de instruções de programação executada pelo código de aplicativo. Por exemplo, se um aplicativo simples tiver um único conjunto de instruções que podem ser executadas em série, haverá apenas um caminho de execução ou thread no aplicativo. Aplicativos mais complexos podem ter várias tarefas que podem ser executadas em tandem, em vez de em série. O aplicativo pode fazer isso iniciando os processos separados para cada tarefa. Porém, a inicialização de um processo é uma operação de recurso intensivo. Em vez disso, um aplicativo pode iniciar threads separados. Eles têm recurso relativamente menos intensivo. Além disso, cada thread pode ser agendado para execução independentemente dos outros threads associados a um processo. Os threads permitem aplicativos complexos para utilizar com mais eficácia uma CPU, mesmo em computadores com uma única CPU. Com uma CPU, apenas um thread pode ser executado de cada vez. Se um thread executar uma operação longa que não usa a CPU, como leitura ou gravação de disco, outro thread poderá ser executado até que a primeira operação seja concluída. Com a possibilidade de executar threads enquanto outros threads estão esperando pela conclusão de uma operação, o aplicativo consegue maximizar o uso da CPU. Isso é especialmente verdadeiro para aplicativos intensivo multiusuário e de E/S de disco, como um servidor de banco de dados. Os computadores que têm vários microprocessadores ou CPUs podem executar um thread por CPU ao mesmo tempo. Por exemplo, se um computador tiver oito CPUs, poderá executar oito threads ao mesmo tempo.

O Linux é um sistema multiprogramado, permitindo a execução de vários processos, e de vários threads associados a eles. Normalmente, uma sessão de usuário possui vários processos interativos (editores de texto, navegadores Web...) e outros que funcionam ininterruptamente, mesmo quando o usuário se ausenta de suas atividades. Esses processos são conhecidos como daemons e são responsáveis por atividades como agendamento de tarefas, controle de fila de impressão, etc.

Os processos podem se comunicar através de pipes, enviando a saída de um processo para outro, e por sinais, manipulando o comportamento de outros. Esses sinais também são conhecidos como interrupções de software. Existem sinais que avisam sobre erros, pedem que um processo interrompa sua execução, informam sobre alguma ocorrência, entre outros. Como todo sistema Unix, cada processo é identificado por um número (o PID). Internamente, o kernel interpreta cada processo ou thread como uma tarefa — processos sem threads possuem somente uma tarefa, e processos com várias threads possuem uma tarefa para cada thread. Cada tarefa possui um código, o TID, atuando semelhante a uma chave primária num banco de dados, e um conjunto de threads relacionado a um processo compartilham do mesmo PID. As tarefas são representadas na memória primária através da estrutura task_struct. Ela guarda, para cada tarefa, as informações sobre os parâmetros de escalonamento, localização dos dados na memória primária, sinais em tratamento e ignorados, valores dos registradores (caso a tarefa vá para segundo plano), a chamada de sistema que esteja atuando sobre o executável, informações sobre o descritor de arquivo, tempo gasto

na execução em modo usuário e modo núcleo, uma pilha que pode ser utilizada pelo processo e outras informações sobre o processo (PID, PID do processo pai e informações de usuário e grupo responsáveis pela tarefa). Os processos são criados no Linux através de uma chamada de sistema chamada fork. Ela é responsável por criar uma cópia do processo que o chamou em outro espaço de memória. Para outro programa ser executado, é necessário utilizar outra chamada, exec. Ela recebe como parâmetros um arquivo executável que esteja na memória secundária, com as variáveis necessárias para execução. Quando a chamada exec é feita, o kernel substitui o executável do processo original na memória pelo executável chamado no parâmetro. Logo, a criação de um processo envolve uma chamada fork e uma exec. Quando o Linux é inicializado, o kernel prepara o hardware para execução, e cria um processo com PID 0, que é o daemon de paginação de memória. Logo após, procura um executável chamado init, que recebe o PID 1 e é responsável por executar todos os outros programas necessários para uma sessão de usuário, iniciando outros daemons e invocando no final os programas getty, que controla a comunicação entre terminais físicos e/ou virtuais, e o programa login, responsável por receber as informações de autenticação do usuário. Existem vários algoritmos que podem ser utilizados para escalonamento de tarefas, e definidos no momento em que o kernel é compilado. O algoritmo definido por omissão é o Completely Fair Queuing (também conhecido como CFQ). Existem outros algoritmos que vêm empacotados no código-fonte do Linux, mas que devem ser ativados pelo usuário, como o Noop Scheduler (otimizado para operação em sistemas com armazenamento SSD) e o Deadline Scheduler, com um algoritmo focado em otimizar o atendimento de processos que lidam com E/S.

Na execução em modo usuário e modo núcleo, uma pilha que pode ser utilizada pelo processo e outras informações sobre o processo (PID, PID do processo pai e informações de usuário e grupo responsáveis pela tarefa). Os processos são criados no Linux através de uma chamada de sistema chamada fork. Ela é responsável por criar uma cópia do processo que o chamou em outro espaço de memória. Para outro programa