simgrid fernando afonso. 2 sumário introdução simulação simgrid xtremweb experimentos trabalhos...
TRANSCRIPT
SimGrid
Fernando Afonso
2
Sumário
• Introdução• Simulação• SimGrid• XtremWeb• Experimentos• Trabalhos futuros• Conclusões
3
Introdução
• Programas distribuídos de larga escala se tornam cada vez mais populares.
• Algumas áreas de estudo sobre esses sistemas são:– Busca e cache de dados;– Algoritmos de escalonamento;– Gerenciamento e compartilhamento de recursos.
4
Introdução
• Diversos aspectos desses sistemas podem ser medidos:– Tempo de resposta;– Throughput;– Escalabilidade;– Tolerância a falhas;– Justiça;– Etc...
5
Introdução
• Algumas maneiras para realizar a validação desses sistemas:– Modelos matemáticos
• Difíceis de se obter– Experimentos em plataformas reais
• Muito demorados• O software deve estar totalmente funcional• Difíceis de serem repetidos
– Simulação• Rápido• Fácil• Pode ser repetido
– Os resultados da simulação são representativos?
6
Simulação
• Não é necessário que o sistema inteiro esteja funcional.
• Os experimentos podem ser controlados e repetidos.
• Os cenários podem ser variados.• Os experimentos podem ser reproduzidos por
outras pessoas.• Tempo de simulação é bem menor que o
tempo de execução real.
7
Simulação
• Um simulador deve ser:– Preciso– Escalável– Tratável– Instanciavel– Relevante
• Problema: cada pesquisador costuma criar o seu simulador de aplicação.– Necessário utilizar um simulador padronizado para
poder comparar diferentes trabalhos.
8
SimGrid
• SimGrid é um conjunto de ferramentas que permite realizar simulações de aplicações distribuídas em ambientes heterogêneos e distribuídos.
• A principal meta do projeto é facilitar a pesquisa de escalonamento para aplicações paralelas e distribuídas em ambientes distribuídos abrangendo desde redes pequenas até grids.
9
SimGrid
10
SimGrid
• MSG– Foi o primeiro módulo de programação distribuída
implementado no SimGrid.– Embora seja bem simples é possível realizar
simulações bem realistas.– Esse módulo serve para testar heurísticas sem
implementar o problema.– Para implementar realmente o problema deve-se
utilizar a plataforma GRAS.– Existe uma versão Java porém suportada somente
nas versões em desenvolvimento.
11
SimGrid
• Utilizam-se arquivos XML para definir a plataforma de execução e o deploy.
• Plataforma:– Poder de CPU– Latência e largura de banda– Rotas entre cada par de nodos
• Deploy:– Custo de CPU e custo de rede das tarefas– Nodos a serem utilizados– Funções dos nodos– Tipo de escalonamento– Etc..
12
SimGrid - Plataforma<platform_description version="1">
<cpu name="Nodo_0" power="99999000"/><cpu name="Nodo_1" power="4307383"/>...<network_link name="Nodo_0_in" bandwidth="50000000" latency="0.007848"/><network_link name="Nodo_0_out" bandwidth="10000000" latency="0.004338"/><network_link name="loopback" bandwidth="498000000" latency="0.000015"/>...<route src="Nodo_0" dst="Nodo_0">
<route_element name="loopback"/></route>...<route src="Nodo_0" dst="Nodo_1">
<route_element name="Nodo_0_out"/><route_element name="Nodo_1_in"/>
</route>...<route src="Nodo_1" dst="Nodo_0">
<route_element name="Nodo_1_out"/><route_element name="Nodo_0_in"/>
</route>...
13
SimGrid - Deploy<platform_description version="1">
<process host="Nodo_0" function="master"><argument value="DYN"/> <!-- Type of scheduling --><argument value="10"/> <!-- Number of tasks to execute --><argument value="10000"/> <!-- Range of the random task cpu requirement --><argument value="10000"/> <!-- Range of the random task net requirement --><argument value="Nodo_1"/><argument value="Nodo_2"/><argument value="Nodo_3"/><argument value="Nodo_4"/>
</process><process host="Nodo_1" function="slave"/><process host="Nodo_2" function="slave"/><process host="Nodo_3" function="slave"/><process host="Nodo_4" function="slave"/>
</platform_description>
14
SimGrid - Masterm_host_t *slaves = NULL; m_task_t *todo = NULL; ...for (i = 0; i < number_of_tasks; i++) {
sprintf(sprintf_buffer, "Task_%d", i); todo[i] = MSG_task_create(sprintf_buffer, task_comp_size, task_comm_size, NULL); }
...for (i = 0; i < number_of_tasks; i++)
MSG_task_put(todo[i], slaves[i % slaves_count], PORT_22); for (i = 0; i < slaves_count; i++)
MSG_task_put(MSG_task_create("finalize", 0, 0, FINALIZE), slaves[i], PORT_22);
15
SimGrid - Slave
int slave(int argc, char *argv[]) { m_task_t task = NULL; while(1) {
MSG_task_get(&(task), PORT_22); if (!strcmp(MSG_task_get_name(task),"finalize")) {
MSG_task_destroy(task);break; }
MSG_task_execute(task); MSG_task_destroy(task); task = NULL; }
return 0; }
16
SimGrid - Main
int main(int argc, char *argv[]) { MSG_error_t res = MSG_OK; MSG_global_init(&argc,argv); if (argc < 3) {
printf ("Usage: %s platform_file deployment_file\n",argv[0]);printf ("example: %s msg_platform.xml msg_deployment.xml\n",argv[0]); exit(1); }
res = test_all(argv[1],argv[2]); MSG_clean(); if(res==MSG_OK)
return 0; else
return 1; }
17
XtremWeb
• Recursos que oferecem processamento buscam jobs para executar.
• Servidor disponibiliza jobs para recurso solicitante.
• Utiliza política de escalonamento FIFO.
18
Experimentos
• Objetivo:– Simular o funcionamento do XtremWeb dentro do
SimGrig.
• Para isso foi utilizada a plataforma MSG.
• Foi modelado um sistema no qual os clientes “escravos” pedem tarefas ao servidor “mestre”.
19
Experimentos
• O servidor está sempre esperando por um cliente requisitar tarefas.
• Cada cliente possui um buffer no servidor responsável por armazenar a última tarefa que lhe foi enviada.
• Caso o cliente execute a tarefa corretamente o servidor a remove do buffer e coloca no buffer a próxima tarefa a ser enviada aquele cliente.
• Caso o cliente falhe o servidor recupera a tarefa e a coloca novamente na fila de tarefas.
20
Experimentos - Slave...sprintf(str, "%d", MSG_process_self_PID());MSG_task_put(MSG_task_create(str, 0, 0, TASK_REQUEST), master, TO_MASTER);while(1) {
MSG_task_get(&(task), PORT_22);if(MSG_task_get_data(task)==FINALIZE){
MSG_task_destroy(task);break; }
if(failiture!=1){MSG_task_execute(task);MSG_task_destroy(task);tarefas_concluidas++; }
else {MSG_task_put(MSG_task_create(str, 0, 0, CLIENT_DOWN), master,
TO_MASTER);break; }
MSG_task_put(MSG_task_create(str, 0, 0, TASK_REQUEST), master, TO_MASTER);}
Return 0;
21
Experimentos - Masterfor (i = 0; i < number_of_tasks; i++) {
MSG_task_get(&request, TO_MASTER);requester = MSG_task_get_source (request);requesterID = atoi(MSG_task_get_name(request));MSG_task_destroy(request);if(MSG_task_get_data(request)!=CLIENT_DOWN
MSG_task_put(todo[i], requester, PORT_22;task_recovery[requesterID] = todo[i]; }
else {todo[i-1]=task_recovery[requesterID];i-=2;slaves_count-=1; }
if(slaves_count==0)break;
22
Experimentos - Master
for (i = 0 ; i < slaves_count; i++) {request = NULL;MSG_task_get(&request, TO_MASTER);
if(MSG_task_get_data(request)!=CLIENT_DOWN) {requester = MSG_task_get_source (request); MSG_task_put(MSG_task_create("finalize", 0,
0, FINALIZE), requester, PORT_22); }MSG_task_destroy(request);
}
23
Experimentos - Finalizaçãofor (i = 0 ; i < slaves_count; i++) {
MSG_task_get(&request, TO_MASTER);MSG_task_execute(request); requester = MSG_task_get_source (request);requesterID = atoi(MSG_task_get_name(request));
if(MSG_task_get_data(request)!=CLIENT_DOWN) {requesters_to_finalize[requesterID] = requester;MSG_task_destroy(request); }
else{
remaining_tasks++;list_of_remaining_tasks[requesterID]=
task_recovery[requesterID]; }}
24
Experimentos - Finalizaçãowhile(remaining_tasks_total>0){
while(remaining_tasks>0){for(i = 0; i < slaves_count; i++)
if(list_of_remaining_tasks[i]!=NULL) {request = list_of_remaining_tasks[i];list_of_remaining_tasks[i] = NULL;break; }
for(i = 0; i < slaves_count; i++)if(requesters_to_finalize[i]!=NULL) {
MSG_task_put(MSG_task_create("test", REQ_CPU, REQ_NET, TASK_REQUEST), requesters_to_finalize[i], PORT_22);
task_recovery[requesterID] = request;remaining_tasks--; if(requesters_to_finalize[i]=NULL;break; }
}....................................}
25
Experimentos - Finalização
MSG_task_get(&request, TO_MASTER);requester = MSG_task_get_source (request);requesterID = atoi(MSG_task_get_name(request));if(MSG_task_get_data(request)!=CLIENT_DOWN) {
requesters_to_finalize[requesterID] = requester;MSG_task_destroy(request);remaining_tasks_total--;}
else {remaining_tasks_total ++; remaining_tasks++;list_of_remaining_tasks[requesterID] =
task_recovery[requesterID]; }
26
Experimentos
27
Experimentos
28
Experimentos
29
Experimentos
30
Limitações
• Para descobrir o ID do cliente é necessário que ele o envie na mensagem.
• Não é possível efetuar troca de mensagens, sendo necessário criar tarefas vazias para troca de informações.
• O número de clientes máximo foi 180.• Último release: Março de 2007.
31
Trabalhos Futuros
• Adicionar a política de escalonamento desenvolvida pelo Eder.
• Realizar testes com diferentes cenários comparando essa política com a política nova.
• Adicionar clientes dinamicamente.• Adicionar tarefas dinamicamente.
32
Conclusões
• O simulador permite a criação de inúmeros cenários mesmo com suas limitações.
• O simulador se mostrou extremamente estável durante todas as execuções.
• Foi possível visualizar nos testes as tarefas sendo recuperadas e redistribuídas.
SimGrid
Fernando Afonso