Laboratório de Sistemas Operacionais 1

Pontifícia Universidade Católica de Campinas

Experimento # 1

1. Introdução

O primeiro experimento teve como base processos. A relação deles no sistema operacional *nix bem como o entendimento e criação dos mesmos.

Partindo do princípio que o computador é uma máquina digital, subentende-se que toda e qualquer medição de tempo é precisa e. Seguindo essa linha de raciocínio foi usado um programa para testes e comprovando que essa regra é uma excessão, ou seja, a medição de duração do tempo levado por um processo não é exata.

Diversos fatores contribuem para que isso ocorra, uma delas é chamada de multi-task (multi-tarefa). Multi-tarefa nada mais é que a capacidade do SO tem de lidar com vários processos (generalizando programas) ao mesmo tempo se utilizando apenas de um processador.

Racionalmente pode-se notar que com apenas 1 processador é muito díficil de processar duas coisas no mesmo e exato momento. A troca de processos entre o processador e a memória acarreta em um atraso, mesmo que pequeno, justificando em partes um dos motivos porque não é medido precisamente o tempo levado por um processo.

Utilizando o programa exemplo, foi medido diversas vezes tempos de execução e seu respectivo desvio total e médio, após isso, o programa fonte foi modificado e novamente nas mesmas condições o tempo foi medido. Veja abaixo a tabela seguida da descrição.

2) Programa exemplo - Experiment-2.c

• /*******************************************************************************

• * Este programa faz parte do curso sobre tempo real do Laboratorio Embry-Riddle

• *

• * Seguem os comentarios originais:

• *

• * Experiment #2: Multi-Tasking, Measuring Drift

• *

• * Programmer: Eric Sorton

• * Date: 1/27/97

• * For: MSE599, Special Topics Class

• *

• * Purpose: When a basic sleep call is used to determine the precise time

• * when an action will occur the problem of drift occurs.

• * The measurement of time is imprecise. Similarly, the time in

• * which the sleep call returns is imprecise. Over time, this

• * will cause the ocurrence of time to drift. Just as if a clock

• * loses 1 second every day, over one day, it is significant, but

• * over a year, it loses 365 seconds, which is over 6 minutes.

• * This is an example of drift.

• *

• * Proposito: Quando uma chamada básica sleep é usada para determinar o

• * instante exato em que alguma acao vai ocorrer, ocorre o problema

• * do desvio. A medicao de tempo e imprecisa. Similarmente, o tempo

• * que demora o retorno da chamada sleep tambem e impreciso. Ao

• * longo do tempo, isto ocasionara um desvio de tempo. Algo como se

• * um relogio perdesse um segundo a cada dia. Ao longo de um dia,

• * essa diferenca e insignificante, mas, ao longo de um ano, sao

• * perdidos 365 segundo, o que e superior a 6 minutos. Este e um

• * exemplo de desvio.

• *

• *******************************************************************************/

• /*

• * Includes Necessarios, verifique se as bibliotecas no diretorio sys/ estao

• * la. Caso nao estejam, verifique onde estao e altere o include

• */

• #include <sys/time.h> /* for gettimeofday() */

• #include <unistd.h> /* for gettimeofday() */

• #include <stdio.h> /* for printf() */

• #include <unistd.h> /* for fork() */

• #include <sys/types.h> /* for wait() */

• #include <sys/wait.h> /* for wait() */

• /*

• * NO_OF_ITERATIONS e o numero de vezes que se repete o loop existente

• * em cada processo. Se este valor for maior, a media calculada sofrera

• * menor desvio.

• */

• #define NO_OF_ITERATIONS 500

• /*

• * NO_OF_CHILDREN e o numero de filhos a serem criados, cada qual responsavel

• * pela medida do desvio. Quanto mais filhos, maior sera o desvio.

• */

• #define NO_OF_CHILDREN 3

• /*

• * SLEEP_TIME corresponde a quantidade de tempo para ficar dormindo.

• * essa quantidade tem efeito no desvio, quanto menor, maior sera o desvio.

• */

• #define SLEEP_TIME 20

• /*

• * MICRO_PER_SECOND define o numero de microsegundos em um segundo

• */

• #define MICRO_PER_SECOND 1000000

• /*

• * Programa Principal, e o programa pai

• */

• int main( int argc, char *argv[] )

• {

• /*

• * start_time e stop_time conterao o valor de tempo antes e depois

• * que as trocas de contexto comecem

• */

• struct timeval start_time;

• struct timeval stop_time;

• /*

• * Outras variaveis importantes

• */

• float drift;

• int count;

• int rtn;

• int child_no;

• /*

• * Criacao dos processos filhos

• */

• rtn = 1;

• for( count = 0; count < NO_OF_CHILDREN; count++ ) {

• if( rtn != 0 ) {

• rtn = fork();

• } else {

• break;

• }

• }

• /*

• * Verifica-se rtn para determinar se o processo e pai ou filho

• */

• if( rtn == 0 ) {

• child_no = count;

• /*

• * Portanto, sou filho. Faco coisas de filho.

• * Primeiro, obter o tempo inicial.

• */

• gettimeofday( &start_time, NULL );

• /*

• * Este loop ocasiona a dormencia do filho, de acordo com

• * SLEEP_TIME, tantas vezes quanto NO_OF_ITERATIONS

• */

• for( count = 0; count < NO_OF_ITERATIONS; count++ ) {

• usleep(SLEEP_TIME);

• }

• /*

• * Paraobter o tempo final

• */

• gettimeofday( &stop_time, NULL );

• /*

• * Calcula-se o desvio

• */

• drift = (float)(stop_time.tv_sec - start_time.tv_sec);

• drift += (stop_time.tv_usec - start_time.tv_usec)/(float)MICRO_PER_SECOND;

• /*

• * Exibe os resultados

• */

• printf("Filho #%d -- desvio total: %.6f -- desvio medio: %.6f\n",

• child_no, drift - NO_OF_ITERATIONS*SLEEP_TIME/MICRO_PER_SECOND,

• (drift - NO_OF_ITERATIONS*SLEEP_TIME/MICRO_PER_SECOND)/NO_OF_ITERATIONS);

• } else {

• /*

• * Sou pai, aguardo o termino dos filhos

• */

• for( count = 0; count < NO_OF_CHILDREN; count++ ) {

• wait(NULL);

• }

• }

• exit(0);

• }

3) Resultados do programa exemplo

A tabela acima demonstra dados medidos em intervalos e situações diferentes de processamento. Nota-se que quanto maior a carga do sistema, maior o desvio, porém isso não é regra, visto que, em alguns momentos o tempo foi menor com uma carga maior.

A tabela acima descreve resumidamente o que foi feito e executado na máquina para aumentar o número de processamento e carga do SO.

Alguns dos programas utilizados, requerem da máquina instruções de alto desempenho, como processamento 3d, vídeos, na sua maioria recursos multi-mídia. Note que essa tabela foi também utilizada depois da modificação do programa exemplo.

4) Programa exemplo modificado - Experiment-2_modificado.c

/*******************************************************************************

* Este programa faz parte do curso sobre tempo real do Laboratorio Embry-Riddle

*

* Seguem os comentarios originais:

*

* Experiment #2: Multi-Tasking, Measuring Drift

*

* Programmer: Eric Sorton

* Date: 1/27/97

* For: MSE599, Special Topics Class

*

* Purpose: When a basic sleep call is used to determine the precise time

* when an action will occur the problem of drift occurs.

* The measurement of time is imprecise. Similarly, the time in

* which the sleep call returns is imprecise. Over time, this

* will cause the ocurrence of time to drift. Just as if a clock

* loses 1 second every day, over one day, it is significant, but

* over a year, it loses 365 seconds, which is over 6 minutes.

* This is an example of drift.

*

* Proposito: Quando uma chamada básica sleep é usada para determinar o

* instante exato em que alguma acao vai ocorrer, ocorre o problema

* do desvio. A medicao de tempo e imprecisa. Similarmente, o tempo

* que demora o retorno da chamada sleep tambem e impreciso. Ao

* longo do tempo, isto ocasionara um desvio de tempo. Algo como se

* um relogio perdesse um segundo a cada dia. Ao longo de um dia,

* essa diferenca e insignificante, mas, ao longo de um ano, sao

* perdidos 365 segundo, o que e superior a 6 minutos. Este e um

* exemplo de desvio.

*

*******************************************************************************/

/*

* Includes Necessarios, verifique se as bibliotecas no diretorio sys/ estao

* la. Caso nao estejam, verifique onde estao e altere o include

*/

#include <sys/time.h> /* for gettimeofday() */

#include <unistd.h> /* for gettimeofday() */

#include <stdio.h> /* for printf() */

#include <sys/types.h> /* for wait() */

#include <sys/wait.h> /* for wait() */

/*

* NO_OF_ITERATIONS e o numero de vezes que se repete o loop existente

* em cada processo. Se este valor for maior, a media calculada sofrera

* menor desvio.

*/

#define NO_OF_ITERATIONS 500

/*

* NO_OF_CHILDREN e o numero de filhos a serem criados, cada qual responsavel

* pela medida do desvio. Quanto mais filhos, maior sera o desvio.

*/

#define NO_OF_CHILDREN 3

/*

* SLEEP_TIME corresponde a quantidade de tempo para ficar dormindo.

* essa quantidade tem efeito no desvio, quanto menor, maior sera o desvio.

*/

//#define SLEEP_TIME 20
// vai ser lido do teclado

/*

* MICRO_PER_SECOND define o numero de microsegundos em um segundo

*/

#define MICRO_PER_SECOND 1000000

/*

* Programa Principal, e o programa pai

*/

int main( int argc, char *argv[] )

{

/*

* start_time e stop_time conterao o valor de tempo antes e depois

* que as trocas de contexto comecem

*/

struct timeval start_time;

struct timeval stop_time;

extern char **environ;

/*

* Outras variaveis importantes

*/

float drift;

int count;

int rtn;

char child_no, st;

int SLEEP_TIME; // para sleep_time ser lido do teclado


/* Ler SLEEP TIME */
while(1)
{
printf("Digite o numero do sleep time, multiplo de 50 : ");
scanf("%d",&SLEEP_TIME);
if((SLEEP_TIME % 50)==0)
break;
}

/*

* Criacao dos processos filhos

*/

for( count = 0; count < NO_OF_CHILDREN; count++ ){

if( rtn != 0 ){

rtn = fork();

}
else{

break;

}
}

if( rtn == 0 ){

child_no = count+48;
st=SLEEP_TIME+48;

execl("Exper_modificado_filho",&child_no,&st,NULL);
}
else {
/*
* Sou pai, aguardo o termino dos filhos
*/
for( count = 0; count < NO_OF_CHILDREN; count++ ) {
wait(NULL);
}

}

exit(0);

}

Experiment-2_modificado_filho.c

#include <sys/time.h> /* for gettimeofday() */

#include <unistd.h> /* for gettimeofday() */

#include <stdio.h> /* for printf() */

#include <sys/types.h> /* for wait() */

#include <sys/wait.h> /* for wait() */

/*

* NO_OF_ITERATIONS e o numero de vezes que se repete o loop existente

* em cada processo. Se este valor for maior, a media calculada sofrera

* menor desvio.

*/

#define NO_OF_ITERATIONS 500

/*

* NO_OF_CHILDREN e o numero de filhos a serem criados, cada qual responsavel

* pela medida do desvio. Quanto mais filhos, maior sera o desvio.

*/

#define NO_OF_CHILDREN 3

/*

* MICRO_PER_SECOND define o numero de microsegundos em um segundo

*/

#define MICRO_PER_SECOND 1000000

int main( int argc, char *argv[])

{

struct timeval start_time;

struct timeval stop_time;

/*

* Outras variaveis importantes

*/

float drift;

int count;

int child_no;

int SLEEP_TIME;

if(argc!=2)

{

printf("\nParametros invalidos!\n\n");

exit(1);

}

child_no=atoi(argv[0]);

SLEEP_TIME=atoi(argv[1]);

gettimeofday( &start_time, NULL );

/*

* Este loop ocasiona a dormencia do filho, de acordo com

* SLEEP_TIME, tantas vezes quanto NO_OF_ITERATIONS

*/

for( count = 0; count < NO_OF_ITERATIONS; count++ ) {

usleep(SLEEP_TIME);

}

/*

* Paraobter o tempo final

*/

gettimeofday( &stop_time, NULL );

/*

* Calcula-se o desvio

*/

drift = (float)(stop_time.tv_sec - start_time.tv_sec);

drift += (stop_time.tv_usec - start_time.tv_usec)/(float)MICRO_PER_SECOND;

/*

* Exibe os resultados

*/

printf("Filho #%d -- desvio total: %.6f -- desvio medio: %.6f\n",

child_no, drift - NO_OF_ITERATIONS*SLEEP_TIME/MICRO_PER_SECOND,

(drift - NO_OF_ITERATIONS*SLEEP_TIME/MICRO_PER_SECOND)/NO_OF_ITERATIONS);

}

4. Resultado do programa modificado

5. Análise dos resultados

Após a modificação do programa exemplo nota-se visualmente um declínio no desvio de execução dos processos.