{\lambda}Scale: Enabling Fast Scaling for Serverless Large Language Model Inference

O artigo apresenta o {\lambda}Scale, um sistema de inferência serverless para grandes modelos de linguagem que utiliza redes RDMA de alta velocidade e a técnica "execute-while-load" para acelerar o dimensionamento de modelos, reduzindo a latência e os custos em comparação com soluções existentes.

O essencial

Imagine que você tem um restaurante muito famoso (o Servidor) que serve pratos incríveis feitos por um chef genial (o Modelo de Inteligência Artificial).

O problema é que, às vezes, o restaurante fica vazio e o chef vai para casa descansar (o modelo é desligado para economizar dinheiro). De repente, acontece um evento especial e 1.000 pessoas chegam ao mesmo tempo pedindo comida (uma pico de tráfego).

O Problema: A "Fome" do Cliente

Nas soluções atuais de computação em nuvem, quando essa multidão chega, o restaurante precisa:

1. Correr para buscar o chef na casa dele (carregar o modelo do disco).
2. Fazer o chef se vestir e se preparar na cozinha (inicializar o modelo).
3. Só depois disso, começar a cozinhar.

Esse processo de "buscar e preparar" demora muito (minutos). Enquanto isso, os 1.000 clientes ficam na porta, com fome e irritados. Para evitar isso, os restaurantes tentam manter 100 chefs prontos o tempo todo, mas isso é um desperdício enorme de dinheiro, pois a maioria fica parada olhando para a parede.

A Solução: O $\lambda$Scale (Lambda Scale)

Os autores do papel criaram o $\lambda$Scale. Pense nele como um sistema de logística revolucionário que muda as regras do jogo. Em vez de esperar o chef estar pronto para começar a cozinhar, o $\lambda$Scale faz duas coisas mágicas:

1. O "Carregamento Enquanto Anda" (Execute-while-load)

Imagine que o chef não precisa estar inteiro na cozinha para começar a trabalhar.

• A Analogia: O modelo de IA é como uma receita gigante dividida em 100 páginas.
• Como funciona: Assim que a primeira página da receita chega na mesa do chef, ele já começa a cozinhar o primeiro prato. Enquanto ele cozinha, a segunda página chega. Ele usa a segunda página para o segundo prato, e assim por diante.
• O Resultado: O cliente não precisa esperar a receita inteira ser impressa para receber o primeiro prato. O serviço começa antes do carregamento terminar.

2. A "Corrida de Estafetas" (Multicast em Rede Rápida)

Como entregar essas páginas da receita para vários chefs ao mesmo tempo?

• A Analogia: Em vez de um único entregador levar a receita para cada chef (o que demora), o $\lambda$Scale usa uma rede de estafetas de alta velocidade (chamada de RDMA, que é como uma estrada de Fórmula 1 para dados).
• O Método: O primeiro chef recebe a receita e, em vez de esperar, ele passa uma cópia para o vizinho enquanto ainda está lendo a primeira página. O vizinho passa para o próximo, e assim por diante, em uma corrente perfeita.
• A Diferença: Sistemas antigos (como o NCCL) funcionam como um "árvore" onde um pai entrega para dois filhos, que entregam para quatro netos. É bom, mas o $\lambda$Scale usa uma "pipa binomial" (um método matemático inteligente) que faz todos os chefs receberem partes da receita simultaneamente e em ordem otimizada, como se fosse um trem de alta velocidade distribuindo caixas.

O Resultado na Prática

Com o $\lambda$Scale:

• Velocidade: O restaurante consegue atender a multidão em segundos, não minutos.
• Economia: Eles não precisam manter 100 chefs prontos o tempo todo. Eles ligam os chefs apenas quando a multidão chega, e como o "carregamento enquanto anda" é tão rápido, ninguém fica esperando.
• Eficiência: O sistema é tão inteligente que, se o chef tiver várias mãos (várias GPUs), ele usa todas elas para copiar a receita mais rápido, e se o modelo for muito grande, ele divide a receita entre vários chefs que trabalham juntos na mesma mesa.

Resumo em uma frase

O $\lambda$Scale é como um sistema de entrega de pizza onde a pizzaria começa a assar a pizza no forno enquanto o motoboy ainda está pegando os ingredientes na loja, e usa uma frota de helicópteros para entregar pedaços da pizza para vários clientes ao mesmo tempo, garantindo que todos recebam sua primeira fatia quase instantaneamente, mesmo em dias de muito movimento.

Em termos técnicos simples: O sistema permite que a Inteligência Artificial comece a responder perguntas antes de ter baixado todo o seu "cérebro" da internet, usando conexões super-rápidas entre os computadores para distribuir o trabalho enquanto o download acontece.

Resumo técnico

1. O Problema

O surgimento da computação serverless ofereceu uma solução atraente para a inferência de modelos de aprendizado de máquina na nuvem, permitindo escalabilidade dinâmica e pagamento pelo uso. No entanto, à medida que os Modelos de Linguagem Grandes (LLMs) crescem em tamanho (dezenas a centenas de bilhões de parâmetros), as plataformas serverless existentes enfrentam desafios críticos:

• Cold Starts (Inícios Frios) Excessivos: O processo de carregar modelos grandes de repositórios remotos (como S3 ou Hugging Face) e inicializá-los em GPUs pode levar de minutos a dezenas de minutos. Isso impede o escalonamento rápido para lidar com picos de carga súbitos (bursts), violando os Acordos de Nível de Serviço (SLOs) de latência.
• Custos de Recursos vs. Escalabilidade: Para mitigar os cold starts, as soluções atuais tendem a:
  1. Superprovisionar GPUs: Manter instâncias ativas e ociosas o tempo todo, o que contradiz o modelo de custo eficiente do serverless e gera desperdício massivo.
  2. Cache em Memória Host/SSD: Tentar manter modelos na memória do host ou SSDs. No entanto, em ambientes multi-tenant com muitos modelos, a memória do host é insuficiente, e o carregamento de SSDs para GPUs é lento (ordem de segundos), criando gargalos.
• Ineficiência de Soluções Atuais: Sistemas existentes (como ServerlessLLM, FaaSNet, NCCL) não conseguem equilibrar a latência de inicialização com o custo de recursos, muitas vezes exigindo que o modelo seja totalmente carregado antes de iniciar qualquer inferência.

2. Metodologia e Arquitetura (𝜆Scale)

O 𝜆Scale é um sistema de inferência serverless projetado para permitir o escalonamento rápido de modelos, combinando carregamento de rede de alta velocidade com execução distribuída durante o carregamento.

Conceitos Chave:

• Execute-While-Load (Executar Enquanto Carrega): A ideia central é que a inferência não precisa esperar o modelo inteiro estar pronto em um nó. A inferência pode começar assim que os primeiros blocos do modelo são recebidos, permitindo que múltiplos nós colaborem na execução enquanto o restante do modelo é transmitido.
• Redes RDMA de Alta Velocidade: O sistema aproveita interconexões de GPU de alta velocidade (400 Gbps com RDMA e GPUDirect RDMA - GDR) para transferência de dados de baixa latência entre nós, evitando a passagem pela CPU/host.

Componentes Principais:

1. 𝜆Pipe (Esquema de Escalonamento de Modelo):

   • Multicast Adaptativo de Modelo: Utiliza um algoritmo de pipeline binomial para distribuir blocos do modelo de forma eficiente. Em vez de um modelo de árvore binária simples, o pipeline binomial permite que múltiplos nós transmitam blocos simultaneamente, maximizando a largura de banda da rede.
   • Estratégia de Transmissão k-Way: Divide o cluster em subgrupos e usa uma ordem de transferência circularmente deslocada para os blocos do modelo. Isso garante que diferentes nós recebam partes diferentes do modelo quase simultaneamente, permitindo a construção rápida de pipelines de execução.
   • Execução em Pipeline Dinâmica: Constrói "pipelines de execução" que abrangem vários nós. Enquanto os blocos chegam, os nós já processam tokens de entrada usando os blocos disponíveis, distribuindo a carga de trabalho.
   • Mudança de Modo (Mode Switching): Assim que o modelo é totalmente carregado, os nós trocam suavemente do modo de execução distribuída (pipeline) para o modo de execução local, sem interromper o serviço.

2. Gerenciamento de Modelo Eficiente:

   • Início de Modelo Orientado à Localidade: O sistema gerencia modelos em diferentes níveis de armazenamento (GPU, Memória Host, SSD/Remoto). Se o modelo estiver na memória do host, ele é carregado diretamente na GPU e inicia a execução distribuída imediatamente. Se estiver "frio" (remoto), inicia o multicast via GDR.
   • Gerenciamento de Memória: Utiliza Tensor Packing (empacotamento contíguo de tensores para transferência em bloco) e pré-alocação de memória GPU para reduzir a sobrecarga de alocação em tempo de execução.

3. Contribuições Principais

• Novo Paradigma de Escalonamento: Introduz o conceito de "Execute-While-Load" para inferência serverless de LLMs, eliminando a necessidade de esperar o carregamento completo do modelo antes de servir requisições.
• Algoritmo 𝜆Pipe: Desenvolveu um esquema de multicast adaptativo baseado em pipeline binomial que otimiza a granularidade dos blocos e a ordem de transferência para minimizar o tempo de montagem do pipeline de execução.
• Suporte a Escalonamento Dinâmico: Diferente de soluções estáticas, o 𝜆Scale pode reconfigurar pipelines de execução em tempo real à medida que novos nós entram no cluster e recebem blocos do modelo.
• Implementação e Otimização: Implementação completa que integra frameworks de inferência (como Llama) com bibliotecas de comunicação de baixo nível (Derecho/RDMC, RDMA, GDR).

4. Resultados de Avaliação

Os autores avaliaram o 𝜆Scale em um testbed com GPUs NVIDIA H800 e cargas de trabalho reais (traces do Alibaba Cloud e Azure OpenAI).

• Latência de Transferência: O 𝜆Scale foi 1,82x mais rápido que o FaaSNet e 1,53x mais rápido que o NCCL na transmissão de modelos em clusters grandes.
• Desempenho de Throughput (Vazão):
  • Em cenários de cold start, o 𝜆Scale foi 3,75x a 11,4x mais rápido que o ServerlessLLM para começar a servir requisições.
  • O sistema consegue escalar a vazão significativamente mais rápido, começando a servir requisições assim que o primeiro bloco do modelo está na GPU, enquanto concorrentes esperam o modelo completo.
• Latência de Ponta (Tail Latency): Em cargas de trabalho reais e bursty, o 𝜆Scale reduziu a latência da cauda (90º percentil) em até 5x em comparação com as melhores soluções existentes.
• Eficiência de Custo: Redução de 17,8% a 31,3% no consumo de tempo de GPU (custo) em comparação com as baselines, devido à capacidade de escalar para cima e para baixo rapidamente sem manter recursos ociosos.
• Micro-benchmarks: Escalonou um modelo Llama-13B em 8 nós em menos de 1 segundo, superando o NCCL em até 1,5x.

5. Significado e Impacto

O trabalho do 𝜆Scale é significativo porque resolve o dilema fundamental da inferência serverless de LLMs: a troca entre latência de inicialização e custo de recursos.

• Viabilidade Operacional: Torna viável oferecer serviços de inferência de LLMs com requisitos de latência estritos (milissegundos) em ambientes serverless, onde a demanda é imprevisível.
• Eficiência Econômica: Permite que provedores de nuvem atendam a picos de demanda sem a necessidade de superprovisionamento caro de GPUs, alinhando-se perfeitamente ao modelo de "pague pelo que usar".
• Avanço Técnico: Demonstra que a combinação de redes de alta velocidade (RDMA) com algoritmos de comunicação coletiva avançados (multicast binomial) e execução distribuída dinâmica pode superar as limitações físicas de transferência de dados de modelos massivos.

Em resumo, o 𝜆Scale redefine como os modelos grandes são escalados na nuvem, transformando o carregamento de modelos de um gargalo estático em um processo dinâmico e colaborativo que acelera a resposta do sistema e reduz custos.