Pontifícia Universidade Católica – Rio de Janeiro
INF1316 – Sistemas Operacionais
Prof. Alexandre Meslin

Aula Prática de SO

Laboratório de Linux

1. Faça download do putty de http://www.inf.puc-rio.br/~lab-di/putty/ssh_windows.htm (pode rodar diretamente do site, não precisa salvar o arquivo). Conecte-se à máquina bizet.inf.puc-rio.br.
    
2. Para compilar o programa use o comando cc de acordo com a seguinte sintaxe:
   cc -o programa programa.c
    
3. O programa a seguir ilustra o uso do comando fork(). O comando fork() cria um processo filho, clone do pai, a partir do ponto da chamada do fork(). Maiores detalhes, use o comando: man fork.

   #include <stdio.h>
   #include <sys/types.h>
   main ()
   {
           int id,i;
   
           id = fork ();
           if (id)
           {
                   /* pai */
                   printf ("Sou pai de %d\n", id);
                   for (i=1;i;i++);
                   puts ("O pai terminou");
           }
           else
           {
                   /* filho */
                   puts ("Sou filho");
                   for (i=1;i;i++);
                   puts ("O filho terminou");
           }
   }

   1. Execute o programa em background (coloque & depois do nome dele): programa &
   2. Verifique o andamento do processo com o comando ps (mais informações em man ps):
      1. ps
      2. ps -ef
   3. Elimine o processo com o comando kill
      1. kill -9 NúmeroDoProcesso
   4. Verifique se o processo morreu
        
4. Este segundo programa cria 4 filhos a partir de um processo pai. Verifique com o comando ps quem é pai de quem.

   #include <stdio.h>
   #include <sys/types.h>
   #define TEMPO0 10000000000
   #define TEMPO1 9000000000
   #define TEMPO2 8000000000
   #define TEMPO3 7000000000
   #define TEMPO4 6000000000
   main()
   {
   	unsigned long int id,i,j;
   
   	for(i=0;i<4;i++)
   		if (!fork()) break;
   
   	switch (i)
   	{
   		case 0:
                 		puts("sou filho 0");
           		for (j=0;j<TEMPO0;j++);
           		puts("filho 0 terminou");
   			break;
       		case 1:
           		puts("sou filho 1");
             		for(j=0;j<TEMPO1;j++);
           		puts("filho 1 terminou");
   			break;
       		case 2:
               		puts("sou filho 2");
               		for(j=0;i<TEMPO2;i++);
               		puts("filho 2 terminou");
   			break;
       		case 3:
              		puts("sou filho 3");
              		for(j=0;j<TEMPO3;j++);
              		puts("filho 3 terminou");
   			break;
       		case 4:
           		puts ("sou pai");
           		for (j=0;j<TEMPO4;j++);
           		puts("pai terminou");   
         	}
   }

5. O próximo programa chamado delay.c realiza uma computação simples do tipo cpu bound:

   #include <stdio.h>
   #include <string.h>
   main (int argc, char *argv[])
   {
   	int i;
   
   	printf ("Processo %s comecando (loop de %d)\n", argv[1], atoi(argv[2]));
   	for (i = 0; i < atoi(argv[2]); i++);
   	printf ("Processo %s terminando\n", argv[1]);
   }

   O programa recebe dois parâmetros: o primeiro e um nome apenas para identificação e o segundo é a quantidade de transmogrifações 3D revolutivas que o programa vai realizar.

   Execute o programa duas vezes em background de acordo com os comandos abaixo e verifique a ordem de término:
   delay P1 100000000 &
   delay P2 200000000 &

   Execute novamente modificando a prioridade do primeiro programa com o comando nice:
   nice -n 19 delay P1 100000000 &
   delay P2 200000000 &
    

6. O comando time mede o tempo de execução de um programa. Maiores informações em man time. Os programas a seguir são do tipo cpu bound e io bound respectivamente:

   #include <stdio.h>
   main ()
   {
   	int i, aux=2;
   	char v[] = {'-', '\\', '|', '/'};
   
   	for (i=0; i < 10000000; i++)
   	{
   		aux *= aux;
   	}
   }
   

   #include <stdio.h>
   main ()
   {
   	int i;
   	char v[] = {'-', '\\', '|', '/'};
   
   	for (i=0; i < 1000; i++)
   	{
   		putchar (v[i%4]);
   		putchar ('\b');
   	}
   }

   Use o comando time cpu e time io para verificar os tempos de execução dos programas.