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