Segundo Experimento SO
Pontifícia Universidade Católica
Puc – Campinas
Grupo 8 - Turma 3 – Professor Tobar
Bruno de André Mazzoco Ra:02150522
César Henrique Kallas
Ra:02099224
Introdução
O objetivo do experimento é entender o funcionamento da
comunicação entre processos concorrentes através de um mecanismo de troca
de mensagens, ou seja, como os processos se comunicam, além de
implementar esse mecanismo na linguagem C.
No experimento foi utilizado um programa exemplo em que há um
processo pai que cria uma fila de mensagens, cria dois filhos, que vão pegar os
tempos em que a mensagem é passada (a mensagem é passada
seqüencialmente para cada filho por isso).
Essas mensagens são passadas através da fila criada pelo pai e a
mesma possui um mesmo número quando usada pelo pai ou pelos filhos. O
primeiro filho pega o tempo atual em que recebe a mensagem fazendo isso um
numero determinado de vezes e o segundo filho calcula o tempo gasto na
troca de mensagem, entre ele e o outro filho.
Dados do programa
Programa original
Número da
execução
Programas ocupando o
processador
Tempo médio
(s)
Tempo máximo
(s)
1
0
0.0000117480
0.0000650000
2
1
0.0004475226
0.0189580005
3
3
0.0001101780
0.0020089999
4
5
0.0004834373
0.0034459999
5
10
0.0001470167
0.0024689999
6
15
0.0001153990
0.0032760000
7
16
0.0000986951
0.0023729999
8
19
0.0000776450
0.0019210000
9
30
0.0000572670
0.0037120001
10
50
0.0000632920
0.0024329999
Programa modificado
•
Número da
execução*
Programas ocupando o
processador
Tempo médio
(s)
Tempo máximo
(s)
1
0
0.0000463880
0.0022760001
2
1
0.0002572780
0.0070719998
3
3
0.0002006618
0.0082240002
4
5
0.0001637839
0.0041379998
5
10
0.0001472140
0.0039059999
6
15
0.0001406960
0.0040480001
7
16
0.0001183778
0.0001183778
8
19
0.0000466140
0.0035780000
9
30
0.0000363900
0.0015700000
10
50
0.0001506960
cada vez, aumentou-se 100 bytes, começando de 0.
0.0020052391
Análise dos resultados
Nos resultados acima pode-se notar duas tabelas, a primeira é em
relação ao programa exemplo original, no qual se mediu os tempos gastos em
10 execuções. Em cada execução, foi acrescido N processos que ocupam o
processador, como se pode ver nas tabelas. E a segunda em relação ao
programa modificado (veja Modificação do Programa mais abaixo).
Nota-se que tem uma lógica, quanto mais carregado o processador
estiver, mais lento será o tempo de troca das mensagens (tempo máximo),
porém como o computador é uma máquina digital, não se tem uma medida
exata. Mas podemos afirmar sim, que quanto mais carregado, maior será o
tempo gasto.
Na segunda tabela temos os dados do programa modificado, no
programa modificado, temos dois lados a analisar. O primeiro corresponde ao
tamanho da mensagem que os processos filhos irão trocar, já que um aumento
N lido no teclado será adcionado a mensagem original, sendo assim, quanto
maior a mensagem, maior será o tempo gasto pra ela trafegar. Em segundo
lugar, o tempo calculado não foi mais no filho que recebe a mensagem, e sim
no pai, no qual criou uma segunda fila pra receber os resultados em uma
matriz de struct.
O programa modificado, em relação a matriz de resultados, não teve
seu tempo alterado (não em relação ao tamanho da mensagem), apenas foi
calculado de forma diferente em outro processo (pai).
Programa que ocupa o processador (cutime.c)
#include <stdio.h>
int main(int argc, char *argv)
{
int x=1;
while(x!=0)
{
x=x*x/x;
x=x+5;
x=x-5;
}
}
Modificação do Programa
Pede-se as seguintes modificações:
•
um valor numérico que deve ser acrescido ao tamanho
original da mensagem a ser enviada seja lido a partir do
teclado;
•
declare uma matriz com o tamanho correspondente ao
número de interações;
•
faça com que o filho receptor não calcule mais os tempos
médio e máximo, ele deve apenas colocar os tempos na
matriz declarada;
•
faça com que o pai calcule e exiba o tempo total, o tempo
médio e o tempo máximo, após o término dos dois filhos.
Cuide para que o valor dos tempos estejam em mili
segundos.
Conclusão
Podemos observar pela tabela dos dados que conforme o tamanho da
mensagem aumenta, ou seja, quanto mais informações um processo tem que
mandar, maior é o tempo para essa mensagem ser passada para outro
processo.
Como os cálculos dos tempos não são exatos em pratica sendo esses
calculados por uma incrementação de variável dentro de um loop o,
processador também gasta um tempo na execução do loop e dos comandos if.
Além disso o programa de carga quando executado varias vezes concorrente
com o programa gera uma disputa pela CPU que não é linear.
O tempo é ainda maior quando ele é calculado depois na matriz pelo
filho que a recebe, não o tempo de envio de mensagem, mas o tempo total de
execução dos processos, da criação a morte deles..
Podemos concluir que esses dados são uma boa aproximação para os
cálculos dos tempos e o experimento forneceu um bom entendimento sobre
como os processos se comunicam através da troca de mensagens e qual a
dependência desse tempo com o tamanho de dados e informação a ser
passada pelas mensagens.