Processos

1. Abra um terminal e execute o comando: pstree -c -p. Descreva o que está vendo (dica: veja o vídeo complementar)

Nesta aula foi discutido o processo básico de fluxo de inicialização de processos e os elementos básicos necessários para que o kernel possa controlar o processo.

Foi disponibilizado um conjunto de vídeos (nas seções acima) que complementam a visão geral dos processos dentro dos ambientes UNIX.

Também foi discutido os estados que um processo pode assumir e também em qual circunstância acontece a migração dos estados. Abaixo segue uma imagem representando os estados e suas possíveis transições.

Para complementar conteúdo passado nos vídeos faça a leitura do seguinte material do livro do prof. Mazieiro:

• O conceito de Tarefa
• Implementação de Tarefas

1. O que é um processo Zumbi? Escreva um programa que crie processos zumbis.
2. Resolva http://www.brunoribas.com.br/so/2019-1/pratica/multiplicacao-matriz.html
3. Resolva http://wiki.inf.ufpr.br/maziero/doku.php?id=so:criacao_de_processos
4. Resolva http://www.dei.isep.ipp.pt/~orlando/so2/processos.htm
5. Familiarize-se com as chamadas: execve(2), clone(2)

6. Considere a seguinte parte de um programa :prof_Orlando:

   int main()
   {
     ...
     pid2=0;
     for(i=0;i<2;i++)
     {
       pid=fork();
       if(pid==0)
         pid2=fork();
       if(pid2==0)
         printf("Exame de SO\n");
     }
     ...
   }
   

   • Quantas vezes é apresentada a frase Exame de SO? Justifique

   • Veja a discussão deste problema no vídeo abaixo:

7. Tendo um vetor de inteiros com mil posições, crie um processo e faça o seguinte: :prof_Orlando:HOT:
   • Os dois processos (pai e filho) fazem o seguinte cálculo: resultado[i]=dados[i]*4+20
   • Cada processo é responsável pelo cálculo de \(500\) posições do vetor dados, colocando o resultado no vetor resultado
   • Os resultados devem ser apresentados seguindo a ordem do vetor (de \([0,499]\) e depois \([500,999]\))
8. Faça um programa que crie 6 processos e: :prof_Orlando:HOT:
   • Cada processo escreve \(200\) números:
     • 1o processo \([0,200]\);
     • 2o processo \([201,400]\);
     • 3o processo \([401,600]\);
     • 4o processo \([601,800]\);
     • 5o processo \([801,1000]\);
     • 6o processo \([1001,1200]\);
   • O processo pai tem de esperar que TODOS os processos filho terminem
9. Tendo um vetor de \(1000\) posições, faça um programa que crie 5 processos e: :prof_Orlando:HOT:

• Leia o Capítulo 6 - Escalonamento de Tarefas do livro do Professor Maziero.
  • Assista o vídeo do prof. Maziero sobre Escalonamento de tarefas.
• Slides sobre Escalonamento do prof. Fabio Rocha

• Resolva os exercícios propostos no Capítulo 6 - Escalonamento de Tarefas do livro do Professor Maziero.

1. Considere que tem definido na função main duas strings em que a primeira tem o seu primeiro nome e a segunda o último. Faça uma função que receba como parâmetros uma string e escreva essa string no monitor. Implemente um programa em que cada string é apresentada por um thread diferente. :prof_Orlando:
2. Considere que tem um array com cinco posições, sendo cada posição constituída pelo número, nome e morada. Faça uma função que recebe como parâmetros uma estrutura desse tipo e imprima o conteúdo dessa estrutura. Implemente um programa que crie 5 threads, "passando" como argumentos uma estrutura desse array (Ex: 0 primeiro thread fica com a primeira posição do array, etc.) :prof_Orlando:
3. Tendo um array de inteiros com 1200 posições, pretende-se calcular resultado[i] = dados[i]*4 + 20. Crie duas threads : :prof_Orlando:
   • o primeiro thread calcula as primeiras 400 posições;
   • o segundo as seguintes 400;
   • o resto é calculado na função main
     • Depois dos cálculos terminarem, devem ser apresentados os valores no monitor (pode ser feito na função main).
4. Dado um array de inteiros com mil posições, crie 5 threads: :prof_Orlando:
   • Dado um número, procurar esse número no array.
   • Cada thread, procura 200 posições.
   • O thread que encontrar o número, deve imprimir a posição do array onde se encontra. Também deve "retornar" como valor de saída o número do thread (1, 2, 3, 4, 5).
   • Os threads que não encontrarem o número devem "retornar" como valor de saída o valor 0.
   • A função main tem de esperar que todos os threads terminem e imprimir o número do thread onde esse número foi encontrado (1, 2, 3, 4, 5).
     • Nota: O array não tem números repetidos.
5. Faça um programa que crie 5 threads. Cada thread é responsável por calcular 200 posições do array resultado (resultado[i] = dados[i]*2+10). Os threads devem imprimir os resultados segundo a ordem do array. :prof_Orlando:

1. Leia o panorama geral de semáforos no linux sem_overview(7)
   • Execute o comando man 7 sem_overview
2. Familiarize-se com as funções:
   • sem_init(3)
   • sem_wait(3)
   • sem_post(3)
   • sem_destroy(3)
   • sem_getvalue(3)
3. Exercício sobre semáforo :prof_WagnerZola:

   • Faça duas funções em linguagem C, que possam ser usadas por THREADS COOPERANTES. A função get_ticket() retorna um número inteiro positivo ÚNICO a qualquer thread que chamá-la. Protótipo:

     int get_ticket();
     

     A função return_ticket(int) deve receber "de volta" um ticket (número inteiro), supostamente obtido anteriormente via get_ticket(), de modo que esse ticket possa ser "reutilizado" por get_tickets subsequentes.

     void return_ticket(int t);
     

   • Mostre (explique) brevemente porque sua get_ticket() retorna inteiros ÚNICOS, i.e., nunca retorna valores repetidos.

     OBS: Caso seja necessário, sua get_ticket() pode ter um número máximo de tickets (NMAX), nesse caso, ele deve retornar \(-1\) para indicar que não pode mais retornar valores novos.

     Veja o vídeo abaixo, para ver a discussão do exercício. Mas assista somente após de tentar resolver o exercício.

4. Tente implementar o exercício de multiplicação de matrizes com Threads, conforme descrito em AQUI (há um exemplo de solução)
   • Experimente com 2,4 e 8 threads.