• permitir a familiarização com algumas chamadas do SO Unix;
• mostrar como ocorre a criação de processos em SOs Unix;
• mostrar um modo para a medição da duração da execução de um programa ou de parte dele;
• permitir a percepção do conceito de "multitasking", multitarefa, e de seus efeitos sobre a execução de um determinado programa.

Duração de um Trecho de Programa

A duração da execução de um trecho de programa dentro do computador nunca pode ser medida com certeza. Primeiramente, um computador é uma máquina digital, então, sua realidade é a execução de uma série de passos simples e determinísticos. Mesmo supondo que estes passos sejam realizados em um segundo ou um nanosegundo, os mecanismos disponíveis para medição de tempo em um computador sempre vão apresentar alguma limitação. Além do mais, o próprio conjunto de passos necessários para medir o tempo causa um profundo efeito no tempo que está sendo medido. Os atos de "ler" o tempo do relógio do sistema e copiar em uma área de memória local, onde o processo pode ter acesso, requer uma quantidade de tempo.

Sistema Multitarefa

Olhando um sistema com um único processador (ou um multi-processador que executa processos múltiplos), no processamento multitarefa diferentes processos conseguem uma parte do tempo disponível do processador. Por exemplo, se três processos precisam executar, o sistema operacional deixará cada processo executar por uma fatia de tempo. Depois que cada processo acabar de usar o processador durante sua fatia de tempo, o ciclo se repetirá. Isto dará a ilusão que todos os processos estão executando concorrentemente, devido à velocidade de execução da CPU.

Comandos para trabalhar com Processos

man - comando através do qual pode-se obter auxílio a respeito de outro comando. Por exemplo, tente chamar "man gettimeofday" (gettimeofday é uma função que é discutida adiante e serve para a leitura de um relógio). Antes de examinar as chamadas de sistema usadas pelo UNIX para executar operações sobre processos, pode ser útil olhar vários comandos que serão úteis na execução deste e dos projetos restantes e dentre eles destacamos: ps e kill

ps - comando que permite ver informações sobre os processos que estão em execução naquele instante na máquina. Digitando ps em uma janela aparecerá uma lista de processos. Embora a maioria dos SOs Unix tenha este comando para relacionar os processos ativos, o mesmo pode ser diferente em cada SO. Execute o comando man ps para aprender mais sobre o comando que lista informações de processos.

kill - O segundo comando importante é o comando kill que é usado para enviar sinais a outros processos (sinais serão cobertos em outro projeto). Para usar este comando digite kill pid, onde pid é a identificação numérica associada a um processo que se quer sinalizar. O pid de um processo pode ser obtido através de vários métodos, mas o mais comum é usar o comando ps. Tenha cuidado com os pids submetidos ao comando kill, pode-se terminar a execução, por exemplo, do shell, que é o programa que processa os comando Unix submetidos após o logon.

Criando e Administrando Processos em C

Existem três chamadas de sistema comuns fornecidas pelo Unix para criar e administrar processos: fork, exec e wait. A primeira chamada é usada para criar processos, a segunda para carregar uma imagem de processo (programa) diferente e a última para esperar pelo término de um processo. Procure executar o comando man sobre estes comandos para informação mais específica.

fork(...) - A chamada fork cria um processo novo. O novo processo é idêntico ao original com exceção de uma diferença secundária, o valor de retorno da chamada fork(...) (há outras diferenças, mas neste momento não têm importância). Para o processo a chamada fork(...) retorna o "pid" do processo filho e para o processo filho a chamada fork(...) retorna o valor 0.

execx(...) - chamada de sistema utilizada para trocar a imagem da aplicação corrente, ou seja, o programa por um outro. É um comando primário para rodar uma aplicação que esteja presente no disco rígido. A típica seqüência de chamadas é fork(...) seguida de execx(...) para começar a rodar um outro programa. As várias diferenças da chamada execx(...) permitem que programas possam ser inicializados com diferentes opções. Consulte também o manual específico de cada sistema operacional (comando "man") para maiores detalhes.

wait(...) - chamada de sistema que força o pai de um processo filho aguardar (em bloqueio) pelo fim da execução de seu filho. Quando um filho existe, wait(...) retorna o pid do filho que terminou. Se o ponteiro status for diferente de NULL, a informação de como o processo filho terminou será copiada na posição apontada por status.

Se estiver interessado, tente mudar algumas das constantes e veja como elas afetam os resultados.

Com base no exemplo, altere o programa de maneira que o número de processos filhos seja lido pelo processo pai a partir do teclado. O número de microsegundos para a chamada usleep (...) deve ser crescente e ser igual a múltiplos de 100, isto é, se o primeiro processo filho chamar usleep(...) por 500microsegundos, o segundo processo filho deve chamar por 600microsegundos, o terceiro por 700microsegundos e assim por diante. Além disso, os filhos não mais calcularão o desvio, mas continuarão a chamar usleep (...) e depois devem ficar em um loop infinito do tipo CPU-bound (isto é, fazendo "espera ocupada").

• o processo pai obtém o tempo inicial chamando "gettimeofday";
• em seguida, o pai deve criar os filhos, armazenando seus pids;
• copie o loop de dormência, aquele com a chamada para usleep (...) para o processo pai;
• o processo pai deve invocar 100 vezes o usleep com tempo de dormência do último filho;
• após as dormências, o processo pai obtém o tempo final através de chamada de sistema "gettimeofday";
• calcule o tempo total de dormência, subtraindo do tempo final o tempo inicial;
• exiba o resultado esperado, o resultado obtido e o desvio;
• use a chamada de sistema "kill(...)" para terminar os processos filhos.