Programação de jogos MMO com DALua

1. Programação de jogos MMO com DALua Ricardo Costa

2. Sumário • Biblioteca DALua • Projeto de jogo MMORPG • Ferramenta de Testes • Resultados dos Testes • Conclusão

3. Biblioteca DALua • Camada de abstração sobre o ALua 6.0 • ALua: sistema de comunicação assíncrona entre processos • Fornece várias facilidades para a implementação de sistemas distribuídos • Contém módulos especializados: • dalua • dalua.app • dalua.causal • dalua.events • dalua.mutex • dalua.timer • dalua.total

4. Biblioteca DALua • Cada máquina pode executar vários processos DALua • Os processos são identificados por uma string única (ex.: “2@192.168.0.1”) • A rede DALua é totalmente conectada (não há roteamento) • É possível comunicar-se com processos que não usam DALua através de canais TCP

5. Módulo dalua • Envio de mensagens • dalua.send(dest_procs, nome_func, arg1, arg2, ...) • Cada mensagem é uma chamada de função remota • dest_procs pode ser um ou mais identificadores de processo • Argumentos podem ser number, string, boolean, table ou function • Retorna um identificador único para a chamada • dalua.acksend • Processos destinatários enviam uma confirmação de recebimento • Exemplo -- Envia uma chamada à função print do processo 2 dalua.send(“2@192.168.1.2”, “print”, “hello world!”)

6. Módulo events • Quando uma ação é finalizada, um evento correspondente é disparado • Publish/Subscribe: os processos podem registrar-se para receber os eventos desejados e tratá-los se necessário • dalua.events.monitor(nome_evento, tratador_do_evento) • dalua.events.ignore(nome_evento, tratador_do_evento) • nome_evento é uma string • tratador_do_evento é uma função • Tratador recebe argumentos sobre o evento • É possível disparar seus próprios eventos • dalua.events.raise(nome_evento, lista_procs, arg1, arg2...)

7. Módulo events • Exemplo require(“dalua”) local contador = 5 function envia() dalua.send(dalua.self(), “print”, “hello world!”) contador = contador – 1 if contador == 0 then dalua.events.ignore(“dalua_send”, envia) end end dalua.events.monitor(“dalua_init”, envia)dalua.events.monitor(“dalua_send”, envia) dalua.init(“127.0.0.1”, 4321)dalua.loop()

8. Módulo mutex • Suporte a exclusão mútua distribuída • dalua.mutex.create(nome_mutex, procs) • Cria um Mutex com nome nome_mutex dentre os processos especificados na tabela procs • dalua.mutex.enter(nome_mutex, mutex_cs, arg1, arg2...) • Efetua um pedido para entrar na região crítica • Ao conseguir, chama a função mutex_cs e seus argumentos • dalua.mutex.leave(nome_mutex) • Libera o acesso à região crítica a outros processos • dalua.mutex.add(nome_mutex, proc) • dalua.mutex.remove(nome_mutex, proc) • Adiciona ou remove processos no Mutex existente

9. Módulo app • Aplicação: um grupo de processos • Processos podem criar, entrar e sair de aplicações • dalua.app.init() • dalua.app.create(nome_app) • dalua.app.join(nome_app) • dalua.app.leave(nome_app) • dalua.app.destroy(nome_app) • Cada processo da aplicação conhece a lista de processos participantes • dalua.app.processes(nome_app) • dalua.app.applications()

10. Módulo app • Exemplo: criando uma aplicação function inicio() dalua.app.init() end function appinit() dalua.app.create(“Grupo”) end function joined(event, status, app, proc) print(“Processo ”..proc..“ entrou em ”..app) dalua.send(dalua.app.processes(“Grupo”), “print”, “Olá membros do Grupo!”) end dalua.events.monitor(“dalua_init”, inicio) dalua.events.monitor(“dalua_app_init”, appinit)dalua.events.monitor(“dalua_app_join”, joined)

11. Módulo timer • Permite executar tarefas periodicamente • dalua.timer.add(proc, periodo, nvezes, func, arg1, arg2...) • Cria um timer que executa a função func e seus argumentos no processo proc por nvezes a cada periodo segundos. • func e os argumentos têm o mesmo formato do dalua.send • Se nvezes for igual a zero, executa indefinidamente • Retorna um identificador de timer • dalua.timer.remove(timerid) • Para e remove o timer especificado (se ainda existir) • Exemplo dalua.timer.add(dalua.self(), 1, 10, “print”, “1 segundo se passou...”)

12. Projeto de jogo MMORPG • Desenvolvemos um protótipo de Massively Multiplayer Online Role-Playing Game usando DALua • Arquitetura cliente-servidor escalável para aceitar um grande número de clientes conectados simultaneamente • Sistema composto por: • Clientes de jogo • Servidores de login • Banco de dados • Servidores de jogo

13. Servidores de Jogo • Sistema dividido em dois clusters de servidores: • Front-end: mantém as conexões dos clientes, distribuídas uniformemente entre os nós do cluster • Back-end: gerencia o estado do jogo, que é balanceado entre os nós do cluster de acordo com a carga de cada parte do mapa • Os clusters fazem parte de uma aplicação DALua e comunicam-se pela rede local • A conexão dos clientes é feita por canais TCP • O cluster pode ser alterado em tempo de execução

14. Arquitetura dos Servidores de Jogo

15. Ferramenta de Testes • Para testar o desempenho e a escalabilidade do sistema, desenvolvemos o Massive Online Test (MOT) • Feito com DALua e IUPLua para a interface de controle • Controla máquinas de teste para disparar grandes quantidades de clientes • Cria processos “espiões” para coletar informações • Uso de memória RAM (disponível/total) • Uso de CPU (%) • Latência de conexão e de resposta (ms) • Tráfego de rede (bytes recebidos/enviados por segundo)

16. MOT em Funcionamento

17. Resultados dos Testes • Configuração dos clusters: • 3 servidores de jogo front-end • 4 servidores de jogo back-end • 3000 clientes • Obtivemos bom desempenho e baixa latência (< 10 ms) • O uso de CPU mostrou-se adequado, nunca saturando a capacidade total das máquinas do cluster • A ferramenta de testes MOT torna possível o diagnóstico de problemas de desempenho encontrados em sistemas distribuídos

18. Conclusão • Foi possível desenvolver um complexo sistema de clusters de forma simplificada com o DALua • A linguagem Lua não deixou a desejar em desempenho • Nosso protótipo de MMORPG foi uma ótima maneira de testar e aprimorar a biblioteca DALua • A ferramenta de testes MOT mostrou-se extremamente útil para analisar o desempenho desse tipo de aplicação

19. Referências • ALua • http://alua.inf.puc-rio.br • DALua • http://alua.inf.puc-rio.br/dalua • “Arquitetura para Servidores de Jogos Online Massivamente Multiplayer” • Link no site do DALua • Contato: rcosta@inf.puc-rio.br