| Name: | Description: | Size: | Format: | |
|---|---|---|---|---|
| 3.62 MB | Adobe PDF |
Authors
Advisor(s)
Abstract(s)
Fault tolerance is a critical component of distributed systems, particularly considering the exponential growth in internet usage and system scale. The resilience and fault tolerance capabilities are essential for maintaining reliability and minimizing downtime. Elixir, with its fault-tolerant features and foundation in Erlang’s “let it crash” philosophy, stands out as a robust tool for building such systems. Nevertheless, other distributed and concurrent languages offer solutions, often leveraging similar concepts in different environments. For instance, Akka, inspired by “let it crash,” provides a toolkit built for Scala. Similarly, Go, celebrated for its built-in concurrency primitives like goroutines and channels, can integrate with the Actor Model through the Proto.Actor
framework. Although all three languages are capable of implementing the Actor Model, Elixir adopts it as a first-class paradigm through its native integration with the Bogdan/Björn’s Erlang Abstract Machine (BEAM) Virtual Machine and the Open Telecom Platform (OTP) toolkit. In contrast, Akka leverages the maturity and optimizations of the Java Virtual Machine (JVM), offering a powerful abstraction over traditional concurrency models. Proto.Actor, on the other hand, introduces a language-agnostic approach to the Actor Model, built upon
Protocol Buffers, which promotes interoperability. These modern tools bring significant fault-tolerant capabilities to software development. However, it is essential to understand how each compares, necessitating the execution of benchmarking. Thus, based on existing literature, the most effective methodology for benchmarking
involves designing a generic application that simulates distributed and fault-tolerant operations. This approach led to a proposed test framework with a distributed, configurable architecture and test scenarios designed to yield measurable results. Empirical benchmarks revealed Elixir consistently delivers high throughput and low variance under moderate to low fault rates, though reconnection latency increases at scale due to centralized coordination bottlenecks. Scala with Akka demonstrated the most stable fault recovery and reconnection latency across all scales, well-suited for large systems with rigorous stability. Go with Proto.Actor offered competitive throughput in small-scale deployments but exhibited scalability limitations in fault detection and recovery.
These findings show no single runtime dominate and each provides distinct trade-offs between throughput, fault recovery and detection. The results highlight how architecture-level decisions, such communication models, significantly impact runtime behavior under fault-prone conditions. Future work includes enhancing multi-node support, simulating more complex fault types, and exploring different actor system designs.
A tolerância a falhas é um componente crítico nos sistemas distribuídos, considerando cada vez mais o crescimento exponencial da internet. As capacidades de resiliência e tolerância a falhas são essenciais para manter a fiabilidade e minimizar o downtime. Elixir, com as suas funcionalidades de tolerância a falhas e a sua base na filosofia "let it crash" de Erlang, destaca-se como uma ferramenta robusta para a construção de tais sistemas. No entanto, outras linguagens distribuídas e concorrentes oferecem soluções, muitas vezes baseadas em conceitos semelhantes em ambientes diferentes. Por exemplo, Akka, inspirado em “let it crash”, fornece um toolkit construído para Scala. De forma similar, Go, celebrado pelas suas primitivas de concorrência incorporadas, como goroutines e channels, pode integrar-se com o Actor Model através da framework Proto.Actor. Embora as três linguagens sejam capazes de implementar o Actor Model, Elixir adota-o como um paradigma de primeira classe através da sua integração nativa com a máquina virtual Bogdan/Björn’s Erlang Abstract Machine (BEAM) e o toolkit Open Telecom Platform (OTP). Em contraste, Akka faz uso da maturidade e das otimizações da Java Virtual Machine (JVM), oferecendo uma abstração poderosa sobre os modelos de concorrência tradicionais. Proto.Actor, por outro lado, introduz uma abordagem agnóstica sobre a linguagem de programação ao Actor Model, constituída por Protocol Buffers, o que promove a interoperabilidade. Estas ferramentas modernas trazem capacidades significativas de tolerância a falhas para o desenvolvimento de software. Contudo, é essencial compreender como cada uma se compara, o que exige uma análise comparativa exaustiva através de benchmarking. Assim, com base na literatura existente, a metodologia mais eficaz envolve a conceção de uma aplicação genérica que simule operações distribuídas e tolerantes a falhas. Esta abordagem levou a uma proposta de uma framework de teste com uma arquitetura distribuída e configurável, e cenários de teste desenhados para produzir resultados mensuráveis. Os benchmarks empíricos revelaram que Elixir é capaz de produzir alto nível de throughput com baixa variabilidade sob qualquer tipo de injeção de erro, embora a latência de reconexão aumente em escala devido a bottlenecks de coordenação centralizada. Scala com Akka demonstrou uma recuperação de falhas e latência de reconexão mais estáveis em todas as escalas, sendo adequado para grandes sistemas com requisitos rigorosos de estabilidade. Go com Proto.Actor ofereceu throughput competitivo em pequena escala, mas exibiu limitações de escalabilidade na deteção e recuperação de falhas devido à gestão da comunicação remota. Estas descobertas mostram que nenhuma solução domina isoladamente e que cada uma oferece compensações distintas entre throughput, recuperação e deteção de falhas. Os resultados destacam como as decisões ao nível da arquitetura, tais como os modelos de comunicação, impactam significativamente o comportamento em condições de falha. O trabalho futuro inclui a melhoria do suporte multi-node, a simulação de tipos de falha mais complexos e a exploração de projetos de sistemas de atores diferentes.
A tolerância a falhas é um componente crítico nos sistemas distribuídos, considerando cada vez mais o crescimento exponencial da internet. As capacidades de resiliência e tolerância a falhas são essenciais para manter a fiabilidade e minimizar o downtime. Elixir, com as suas funcionalidades de tolerância a falhas e a sua base na filosofia "let it crash" de Erlang, destaca-se como uma ferramenta robusta para a construção de tais sistemas. No entanto, outras linguagens distribuídas e concorrentes oferecem soluções, muitas vezes baseadas em conceitos semelhantes em ambientes diferentes. Por exemplo, Akka, inspirado em “let it crash”, fornece um toolkit construído para Scala. De forma similar, Go, celebrado pelas suas primitivas de concorrência incorporadas, como goroutines e channels, pode integrar-se com o Actor Model através da framework Proto.Actor. Embora as três linguagens sejam capazes de implementar o Actor Model, Elixir adota-o como um paradigma de primeira classe através da sua integração nativa com a máquina virtual Bogdan/Björn’s Erlang Abstract Machine (BEAM) e o toolkit Open Telecom Platform (OTP). Em contraste, Akka faz uso da maturidade e das otimizações da Java Virtual Machine (JVM), oferecendo uma abstração poderosa sobre os modelos de concorrência tradicionais. Proto.Actor, por outro lado, introduz uma abordagem agnóstica sobre a linguagem de programação ao Actor Model, constituída por Protocol Buffers, o que promove a interoperabilidade. Estas ferramentas modernas trazem capacidades significativas de tolerância a falhas para o desenvolvimento de software. Contudo, é essencial compreender como cada uma se compara, o que exige uma análise comparativa exaustiva através de benchmarking. Assim, com base na literatura existente, a metodologia mais eficaz envolve a conceção de uma aplicação genérica que simule operações distribuídas e tolerantes a falhas. Esta abordagem levou a uma proposta de uma framework de teste com uma arquitetura distribuída e configurável, e cenários de teste desenhados para produzir resultados mensuráveis. Os benchmarks empíricos revelaram que Elixir é capaz de produzir alto nível de throughput com baixa variabilidade sob qualquer tipo de injeção de erro, embora a latência de reconexão aumente em escala devido a bottlenecks de coordenação centralizada. Scala com Akka demonstrou uma recuperação de falhas e latência de reconexão mais estáveis em todas as escalas, sendo adequado para grandes sistemas com requisitos rigorosos de estabilidade. Go com Proto.Actor ofereceu throughput competitivo em pequena escala, mas exibiu limitações de escalabilidade na deteção e recuperação de falhas devido à gestão da comunicação remota. Estas descobertas mostram que nenhuma solução domina isoladamente e que cada uma oferece compensações distintas entre throughput, recuperação e deteção de falhas. Os resultados destacam como as decisões ao nível da arquitetura, tais como os modelos de comunicação, impactam significativamente o comportamento em condições de falha. O trabalho futuro inclui a melhoria do suporte multi-node, a simulação de tipos de falha mais complexos e a exploração de projetos de sistemas de atores diferentes.
Description
Keywords
Distributed Systems Fault Tolerance Strategies Actor Model Benchmarking