Provuse: Platform-Side Function Fusion for Performance and Efficiency in FaaS Environments

O artigo apresenta o Provuse, uma otimização transparente do lado da plataforma que funde automaticamente funções FaaS independentes em tempo de execução para eliminar instâncias redundantes, reduzindo significativamente a latência e o consumo de recursos sem exigir alterações no código do desenvolvedor.

O essencial

Imagine que você está organizando uma grande festa e precisa entregar mensagens para várias pessoas em diferentes cômodos da casa.

No mundo atual das computações em nuvem (chamado de FaaS ou "Função como Serviço"), o sistema funciona assim:

1. Você pede para o "gerente" (a plataforma) entregar uma mensagem para o Cozinheiro.
2. O gerente acorda o Cozinheiro, ele faz o trabalho e entrega a resposta.
3. Imediatamente, você pede para o gerente entregar uma mensagem para o Jardineiro (que o Cozinheiro precisava).
4. O gerente acorda o Jardineiro, ele faz o trabalho e entrega a resposta.

O Problema:
Isso gera dois custos extras:

• Tempo: O gerente perde tempo correndo entre os cômodos e acordando cada pessoa separadamente.
• Dinheiro: Como você paga por "tempo de trabalho" e "acordar a pessoa", você acaba pagando duas vezes pelo mesmo processo (uma vez para o Cozinheiro e outra para o Jardineiro), mesmo que eles estivessem trabalhando no mesmo projeto. Isso é chamado de "cobrança dupla".

---

A Solução: O "Provuse" (O Mergulhador de Funções)

O artigo apresenta uma nova tecnologia chamada Provuse. Pense no Provuse como um super-gerente inteligente que trabalha nos bastidores da plataforma, sem que você (o dono da festa) precise mudar nada na sua lista de tarefas.

Como funciona a analogia?

1. A Observação: O Provuse fica de olho nas mensagens. Ele percebe que, sempre que o Cozinheiro precisa do Jardineiro, ele chama o Jardineiro imediatamente e espera a resposta (isso é uma chamada "síncrona").
2. A Fusão (O "Fusion"): Em vez de manter o Cozinheiro e o Jardineiro em cômodos separados, o Provuse decide: "E se juntarmos esses dois em um único cômodo?".
3. A Execução: O Provuse pega o uniforme do Cozinheiro e o do Jardineiro, coloca-os em um único "traje" (um único container de software) e os deixa trabalhando lado a lado.
4. O Resultado: Quando a mensagem chega, o Cozinheiro-Jardineiro (agora uma só pessoa) faz as duas tarefas instantaneamente, sem precisar correr para outro cômodo ou acordar outra pessoa.

O Que Isso Significa na Vida Real?

• Sem Mudar o Código: O dono da festa (o desenvolvedor) não precisa reescrever a lista de tarefas. Ele continua pedindo para o Cozinheiro e depois para o Jardineiro. O Provuse faz a mágica nos bastidores.
• Mais Rápido: Como não há tempo perdido correndo entre cômodos ou acordando pessoas, a festa acontece muito mais rápido. O artigo mostrou que as tarefas ficaram 26% mais rápidas em média.
• Mais Barato: Como você não precisa pagar para acordar duas pessoas separadas, e como elas ocupam menos espaço (memória RAM) trabalhando juntas, o custo cai drasticamente. O artigo mostrou uma economia de 53% na memória usada.

Onde isso foi testado?

Os pesquisadores testaram essa ideia em dois cenários diferentes, como se testassem em duas casas de tamanhos diferentes:

1. tinyFaaS: Uma casa pequena e simples (ideal para borda/edge computing).
2. Kubernetes: Um grande prédio de apartamentos complexo (o padrão da indústria atual).

Em ambos os casos, a estratégia funcionou perfeitamente.

Resumo Final

O Provuse é como um "otimizador invisível". Ele pega funções de software que conversam muito entre si e as une em um único bloco de trabalho.

• Para o usuário: É mágica. Nada muda, mas tudo fica mais rápido e barato.
• Para a empresa: É economia pura. Menos servidores ligados, menos tempo de processamento e menos dinheiro gasto.

É como se, em vez de você ter que ligar para o encanador e depois para o eletricista separadamente, você contratasse um "encanador-eletricista" que resolve os dois problemas de uma vez só, sem você precisar saber disso.

Resumo técnico

Resumo Técnico: Provuse

1. O Problema

As plataformas de Function-as-a-Service (FaaS) oferecem escalabilidade e eficiência de custos, mas enfrentam desafios significativos em aplicações complexas compostas por múltiplas funções. Os principais problemas identificados são:

• Sobrecarga de Latência e Recursos: A comunicação entre funções (chamadas de função para função) introduz latência de rede e custos de inicialização de runtime.
• Cobrança Dupla (Double Billing): Em modelos de FaaS, quando uma função chama outra de forma síncrona, ambas são cobradas pelo tempo de execução e alocação de recursos, mesmo que a segunda função esteja apenas aguardando ou executando parte do fluxo lógico. Isso gera ineficiência de custos e latência desnecessária.
• Complexidade de Otimização: Otimizações atuais geralmente exigem que os desenvolvedores modifiquem o código ou a configuração de implantação, o que vai contra a promessa de abstração da infraestrutura do FaaS.

2. Metodologia e Arquitetura (Provuse)

O Provuse é uma solução de otimização transparente e do lado do provedor (platform-side). Ele realiza a fusão de funções (function fusion) automaticamente em tempo de execução, sem exigir alterações no código do usuário.

Principais Componentes:

1. Function Handler (Gerenciador de Funções):
   • Implanta-se junto com o código da função.
   • Monitora as chamadas de saída (sockets) de cada instância de função.
   • Detecta padrões de comunicação síncrona (onde a thread de envio aguarda a conclusão da chamada).
   • Ao detectar uma chamada síncrona entre duas funções, notifica o componente Merger com os identificadores das funções envolvidas.
2. Merger (Fusor):
   • Recebe a solicitação de fusão e acessa o runtime de contêineres.
   • Extrai os sistemas de arquivos dos contêineres das duas funções ativas.
   • Mescla esses sistemas de arquivos em um único sistema de arquivos unificado, preservando os identificadores originais para evitar conflitos de nomes.
   • Constrói uma nova imagem de contêiner que contém o código de ambas as funções e um novo Function Handler.
   • Implanta o novo contêiner combinado, redireciona o tráfego para ele e encerra as instâncias originais para liberar recursos.

Abordagem de Implementação:

• O sistema foi implementado em duas plataformas distintas para validar a compatibilidade: tinyFaaS (um runtime leve focado em edge) e Kubernetes (usado como base para plataformas como Knative e OpenFaaS).
• O Function Handler foi escrito em Python, enquanto o Merger foi escrito em Rust.
• A fusão é baseada na análise de padrões de invocação em tempo de execução, não exigindo análise estática do código-fonte.

3. Contribuições Chave

• Fusão Transparente: A primeira abordagem que realiza a fusão de funções inteiramente do lado da plataforma, mantendo a abstração para o desenvolvedor. Os usuários não precisam alterar código, anotações ou configurações de implantação.
• Eliminação de Cobrança Dupla: Ao consolidar funções que se chamam frequentemente em uma única unidade de execução, elimina-se a sobrecarga de chamadas remotas e a cobrança redundante de recursos.
• Compatibilidade com Orquestração: Demonstração de que essa otimização é viável tanto em runtimes leves (tinyFaaS) quanto em ambientes de orquestração de contêineres complexos (Kubernetes).
• Preservação de Semântica: A fusão mantém as fronteiras lógicas das funções do ponto de vista do desenvolvedor, enquanto otimiza a execução física.

4. Resultados da Avaliação

Os autores avaliaram o Provuse usando dois casos de uso (aplicações TREE e IOT) em ambas as plataformas (tinyFaaS e Kubernetes), comparando a implantação padrão (vanilla) com a otimizada.

Métricas Principais:

• Redução de Latência:
  • Redução média de latência ponta-a-ponta de 26,33% em todos os benchmarks.
  • Exemplo específico (IOT no tinyFaaS): Latência mediana caiu de 807 ms para 574 ms (28,9% de melhoria).
  • Exemplo específico (TREE no Kubernetes): Latência mediana caiu de 456 ms para 358 ms (21,5% de melhoria).
• Redução de Uso de Memória (RAM):
  • Redução média de uso de RAM de 53,57%.
  • Isso ocorre porque menos instâncias de funções precisam ser mantidas ativas simultaneamente.
• Estabilidade: As melhorias foram consistentes em diferentes tipos de aplicações e ambientes de orquestração, com distribuições de latência estáveis após a fase de fusão.

5. Significado e Conclusão

O trabalho demonstra que a otimização de infraestrutura em nível de plataforma é uma estratégia eficaz para mitigar as ineficiências inerentes aos modelos FaaS compostos.

• Impacto Econômico e de Desempenho: A fusão automática reduz custos operacionais (menos cobrança de tempo de execução e memória) e melhora a experiência do usuário final (menor latência).
• Viabilidade Técnica: Prova que é possível realizar otimizações complexas (como a reconstrução de imagens de contêiner em tempo de execução) de forma transparente, sem sobrecarregar o desenvolvedor.
• Limitações e Futuro: O protótipo atual suporta apenas código Python e assume que as funções fusionadas pertencem ao mesmo domínio de confiança (devido à redução do isolamento). O trabalho futuro visa expandir o suporte a outras linguagens e modelos de implantação (Bring-Your-Own-Container), além de explorar otimizações híbridas.

Em suma, o Provuse oferece um caminho prático para tornar as aplicações serverless mais eficientes em termos de custo e desempenho, resolvendo o problema da "cobrança dupla" através da consolidação inteligente de execução.