Universidade Federal de Alagoas Instituto de Computação
Disciplina: Sistemas Distribuídos
Semestre letivo: 2016.1
Professor: André Lage Freitas
Importante. Leia atentamente essa seção pois só serão aceitos trabalhos que obedecerem as a especificações a seguir.
Baseado(a) no exemplo a seguir de implementação do B-multicast em Julia, façam os exercícios descritos nesse documento.
In [12]:
function B_multicast(g,m,B_deliver)
for p in g
remotecall(p, B_deliver, m)
end
end
# Adding 3 processes (workers)
#addprocs(3)
# My group is composed by all workers
g = workers()
# Multicasting "oi!" message to group `g` by assuming `println` as B_deliver function.
B_multicast(g,"oi!",println)
Adicione 10 processos com o comando addprocs
abaixo.
Atenção: sua instalação local de Julia pode não conseguir adicionar 10 processos, use a JuliaBox.
In [26]:
# Implementation of the asynchronous B-multicast.
function B_multicastAsync(g,m,B_deliver)
for p in g
remotecall(p, B_deliver, m)
end
end
# Remove all existing processes
rmprocs(workers())
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
# Multicasting "oi!" message to group `g` by assuming `println` as B_deliver function.
B_multicastAsync(g,"oi!",println)
Modifique a implementação do B-multicast para utilizar communicação síncrona.
In [24]:
# Implementation of the synchronous B-multicast.
function B_multicastSync(g,m,B_deliver)
for p in g
remotecall_wait(p, B_deliver, m)
end
end
# Remove all existing processes
for i in workers()
rmprocs(i)
end
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
# Multicasting "oi!" message to group `g` by assuming `println` as B_deliver function.
B_multicastSync(g,"oi!",println)
Execute as duas versões do B-multicast (síncrona e assíncrona) e compare as saídas.
A ordem das mensagens das saídas foram as mesmas para ambas versões do B-multicast? Por quê?
Resposta: Não foram as mesmas. A primeira versão (assíncrona) retornou as mensagens em ordens aleatórias para cada execução feita. Já a segunda versão (síncrona), retornou para cada execução a mesma sequência de mensagens ordenada pela ordem de emissão da mensagem. Isso se deve ao fato de que após uma chamada remota síncrona a próxima chamada só será executada após o termino da chamada corrente. Já no B-multicast assíncrono todas as chamadas remotas são executas na saquência independentemente do retorno de uma outra chamada retorna e a mensagem é mostrada conforme ela é retornada.
Meça o tempo de execução duas versões do B-multicast (síncrona e assíncrona). Dica: utilize a macro @time
.
In [54]:
function B_multicastAsync(g,m,B_deliver)
for p in g
remotecall(p, B_deliver, m)
end
end
function B_multicastSync(g,m,B_deliver)
for p in g
remotecall_wait(p, B_deliver, m)
end
end
# Remove all existing processes
for i in workers()
rmprocs(i)
end
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
times = Array(Any, 50)
for i = 1:50
times[i] = @elapsed B_multicastAsync(g,"oi!",println)
end
for i = 1:50
print(times[i])
print("\n")
end
Após executar 50 vezes o B-multicast síncrono e assíncrono foi gerado um arquivo ".csv" que foi utilizado no ambiente R para a geração de alguns dados importantes que segue logo a baixo:
Síncrono | Assíncrono |
---|---|
Min. :0.001607 | Min. :0.0005104 |
1st Qu.:0.001690 | 1st Qu.:0.0005534 |
Median :0.001757 | Median :0.0005762 |
Mean :0.001942 | Mean :0.0016471 |
3rd Qu.:0.001930 | 3rd Qu.:0.0006123 |
Max. :0.007594 | Max. :0.0253185 |
Gráfico:
Observação: Os dados usádos e o código em R usados para gerar esse gráfico podem ser encontrados em: https://github.com/danielsanfr/universitys-homeworks/tree/master/distributed-systems
Resposta: Como é possível notar no gráfico a cima, a versão assíncrona tem menor tempo de execução em média, porém seu intervalo de confiança é muito grande em comparação ao da versão síncrona, logo, levando em consideração os intervalos de confiança é sensato afirmar que a versão sincrona tem o menor tempo de execução!
Isso se deve ao fato da versão assíncrona ter que se preocupar com o gerenciamento do recebimento e envio das mensagens assíncronas, o que não ocorre na versão síncrona, que para situações mais simples e de pouca transferência de dados acaba sendo mais eficiente.
Implemente duas versões do algoritmo R-multicast: uma assíncrona e outra síncrona.
In [17]:
# Implementation of the synchronous R-multicast.
function R_multicastSync(g, m, B_deliver)
received = Int[]
for p in g
remotecall_wait(p, B_deliver, m)
push!(received, p)
end
for p in g
if !(p in received)
remotecall_wait(p, B_deliver, m)
push!(received, p)
end
end
end
# Remove all existing processes
for i in workers()
rmprocs(i)
end
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
# Multicasting "oi!" message to group `g` by assuming `println` as B_deliver function.
R_multicastSync(g,"oi!",println)
In [21]:
# Implementation of the asynchronous R-multicast.
function R_multicastAsync(g, m, B_deliver)
received = Int[]
for p in g
remotecall(p, B_deliver, m)
push!(received, p)
end
for p in g
if !(p in received)
remotecall(p, B_deliver, m)
push!(received, p)
end
end
end
# Remove all existing processes
for i in workers()
rmprocs(i)
end
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
# Multicasting "oi!" message to group `g` by assuming `println` as B_deliver function.
R_multicastAsync(g,"oi!",println)
Faça a mesma análise de desempenho para o R-multicast que você fez no Exercício 2.
In [30]:
function R_multicastAsync(g, m, B_deliver)
received = Int[]
for p in g
remotecall(p, B_deliver, m)
push!(received, p)
end
for p in g
if !(p in received)
remotecall(p, B_deliver, m)
push!(received, p)
end
end
end
function R_multicastSync(g, m, B_deliver)
received = Int[]
for p in g
remotecall_wait(p, B_deliver, m)
push!(received, p)
end
for p in g
if !(p in received)
remotecall_wait(p, B_deliver, m)
push!(received, p)
end
end
end
# Remove all existing processes
for i in workers()
rmprocs(i)
end
# Add 10 processes (workers)
addprocs(10)
# My group is composed by all workers
g = workers()
times = Array(Any, 50)
for i = 1:50
times[i] = @elapsed R_multicastSync(g,"oi!",println)
end
for i = 1:50
print(times[i])
print("\n")
end
Após executar 50 vezes o R-multicast síncrono e assíncrono foi gerado um arquivo ".csv" que foi utilizado no ambiente R para a geração de alguns dados importantes que segue logo a baixo:
Síncrono | Assíncrono |
---|---|
Min. :0.001578 | Min. :0.0002562 |
1st Qu.:0.001707 | 1st Qu.:0.0002874 |
Median :0.001815 | Median :0.0004611 |
Mean :0.023165 | Mean :0.0037654 |
3rd Qu.:0.002137 | 3rd Qu.:0.0005044 |
Max. :1.034427 | Max. :0.0700710 |
Gráfico:
Observação: Os dados usádos e o código em R usados para gerar esse gráfico podem ser encontrados em: https://github.com/danielsanfr/universitys-homeworks/tree/master/distributed-systems
Resposta: No caso do R-multicast pudemos notar que a versão assíncrona teve um tempo de execução muito menor. Isso se deve ao fato de que como agora é necessário fazer uma verificação se a mensagem foi recebida, a versão síncrona acaba demorando bem mais nessas verificações.
Para cada uma das comparações abaixo, qual dos algoritmos teve o menor tempo de execução? Por quê?
Resposta: O algoritmo B-multicast teve o menor tempo de execução pois nesse algoritmo não é necessário verificar se a mensagem foi recebida.
Resposta: Aqui novamente o algoritmo B-multicast teve menor tempo de execução, isso ocorreu pelo mesmo motivo mostrato na pergunta anterior, o B-multicast é mais simples e não precisa verificar se a mensagem foi recebida.
As respostas deverão ser entregues nos devidos campos desse arquivo, ou seja, em Markdown e no formato IJulia Notebook.
O programa deve ser implementado na linguagem de programação Julia. Seu trabalho será testado na JuliaBox, portanto teste seu arquivo IJulia na JulizBox antes de enviá-lo.
O arquivo IJulia Notebook deverá ser entregue ao Professor exclusivamente por e-mail para o seguinte endereço: prof.alage (no) gmail com
Será registrada como data de recebimento do trabalho a data indicada pelo servidor de e-mail do Professor.
A responsabilidade sobre a integridade do arquivo contendo trabalho é exclusivamente dos discentes. Serão ignorados os trabalhos cujos arquivos não conseguirem ser abertos ou se o e-mail não chegar à caixa de entrada de e-mail do Professor.
O prazo de entrega sem atraso é o dia 12/10/16.
Trabalhos entregues com atraso serão aceitos, no máximo, até o o dia 16/10/16. Serão descontados 5% da nota obtida por dia de atraso.
O(a) discente que realizar mais tarefas, além do que foi especificado neste trabalho, o professor atribuirá de 0,5 a 1,0 ponto extra a depender da relevância da contribuição no programa. O critério será decidido pelo professor.
O(a) discente deve indicar qual é a tarefa executada. Por exemplo, adição de funcionalidades, armazenamento de dados em arquivo, documentação de código, comentários em inglês sem erros ortográficos, etc.
Plágio A nota zero será atribuída caso haja qualquer tipo de cópia parcial ou integral assim como as devidas medidas legais. Leia a cartilha sobre plágio.
Esse material foi elaborado pelo Prof. André Lage Freitas e está licenciado sob a licença GNU General Public License v3.0.