A Arachne Tradução

0 - Abstract

Arachne é uma nova implementação de threads em nível de usuário que fornece baixa latência e alta taxa de transferência para aplicativos com threads extremamente curtas.

A principal vantagem do Arachne é sua capacidade de lidar com threads extremamente curtas com baixa latência e alta taxa de transferência. Ele alcança isso usando uma abordagem consciente do núcleo para gerenciamento de thread, onde cada thread é atribuído a um núcleo específico e o número de núcleos que um aplicativo precisa é determinado dinamicamente com base em sua carga de trabalho. O Arachne também usa uma estrutura de dados sem bloqueio para gerenciamento de thread, o que reduz a contenção e melhora a escalabilidade. A avaliação do Arachne aborda várias questões, incluindo quão eficientes são seus primitivos de threading em comparação com outros sistemas de threading e se sua abordagem consciente do núcleo produz benefícios significativos para aplicativos com baixa latência. Os resultados mostram que o Arachne supera outros sistemas de threading em termos tanto de latência quanto de taxa de transferência, especialmente para threads curtas. A abordagem consciente do núcleo também fornece benefícios significativos para aplicativos com baixa latência, reduzindo a latência média em até 50%.

1 - Introdução

Uma das razões pelas quais é difícil combinar baixa latência e alta taxa de transferência é que os aplicativos devem gerenciar seu paralelismo com um recurso virtual (threads); eles não podem dizer ao sistema operacional quantos recursos físicos (núcleos) precisam e não sabem quais núcleos foram alocados para seu uso. Como resultado, os aplicativos não podem ajustar seu paralelismo interno para corresponder aos recursos disponíveis e não podem usar o conhecimento específico do aplicativo para otimizar o uso de recursos. Isso pode levar tanto à subutilização quanto à sobrecarga dos núcleos, resultando em uma utilização inadequada dos recursos e/ou desempenho subótimo. A única solução para as aplicações é fixar as threads aos núcleos, o que resulta em subutilização dos núcleos dentro da aplicação e não impede que outras aplicações sejam agendadas nos mesmos núcleos.

Arachne é um novo sistema de gerenciamento de threads que resolve problemas ao dar visibilidade às aplicações sobre os recursos físicos que estão usando. Chamamos essa abordagem de gerenciamento de thread consciente do núcleo. No Arachne, as threads da aplicação são gerenciadas inteiramente em nível de usuário; elas não são visíveis para o sistema operacional. As aplicações negociam com o sistema sobre os núcleos, não sobre as threads. Os núcleos são alocados para uso exclusivo de aplicações individuais e permanecem alocados a uma aplicação por longos intervalos (dezenas de milissegundos). Cada aplicação sempre sabe exatamente quais núcleos foram alocados para ela e decide como agendar as threads da aplicação nos núcleos.

Um árbitro de núcleos decide quantos núcleos alocar para cada aplicação e ajusta as alocações em resposta às mudanças nos requisitos da aplicação.

Arachne é novo das seguintes maneiras:

O Arachne contém mecanismos para estimar o número de núcleos necessários para uma aplicação enquanto ele é executado.

Arachne permite que cada aplicativo defina uma política de núcleo, que determina no ambiente de execução quantos núcleos o aplicativo precisa e como as threads são colocadas nos núcleos disponíveis.

O ambiente de execução Arachne foi projetado para minimizar falhas de cache. Ele usa uma nova representação de informações de agendamento sem filas prontas, o que permite baixa latência e mecanismos escaláveis para criação, agendamento e sincronização de threads.

O Arachne fornece uma formulação mais simples do que as ativações do escalonador, com base no uso de uma thread de kernel por núcleo.

O Arachne roda totalmente fora do kernel e não precisa de modificações no kernel; o árbitro de núcleo^[a] é implementado no nível do usuário usando o mecanismo cpuset do Linux. Os aplicativos Arachne podem coexistir com aplicativos tradicionais que não usam o Arachne.

2 O problema do thread

O memcached define um tamanho estático de de threads(de kernel), caso ele tenha uma demanda maior que a quantidade que ele tem disponível ele irá multiplexar as threads nos núcleos disponíveis o que irá gerar atrasos, caso a demanda for menor do que ele tem prefixado ele irá subutilizar o sistema e o núcleo corre o risco de entrar em estado de economia de energia.

O Ramcloud opera de forma similar ao memched, ele subutiliza suas threads(de kernel) quando recebe solicitações gravação, já que espera uma resposta de um outro servidor de backup antes de responder a solicitação.

Se o trabalhador(thread) fosse dormir, levaria vários microssegundos para acordá-lo novamente; além disso, as despesas gerais de troca de contexto são muito altas para realizar muito trabalho útil em tão pouco tempo. Como resultado, o núcleo da thread de trabalho é desperdiçado em 70-80% do tempo para processar uma solicitação de gravação

O objetivo do Arachne é fornecer um sistema de gerenciamento de threads que permita uma melhor combinação de baixa latência e alta taxa de transferência. Por exemplo, cada aplicativo deve corresponder sua carga de trabalho aos núcleos disponíveis, usando apenas quantos núcleos forem necessários e ajustando dinamicamente seu paralelismo interno para refletir o número de núcleos alocados a ele. Além disso, Arachne deve fornecer uma implementação de threads de nível de usuário que seja eficiente o suficiente para ser usado para threads de vida muito curta e que permita que um trabalho útil seja feito durante breves bloqueios, como aqueles para solicitações aninhadas.

3 Visão geral de Arachne

O árbitro de núcleo consiste em um processo de usuário autônomo mais uma pequena biblioteca vinculada a cada aplicativo.

O ambiente de execução Arachne e políticas de núcleo são bibliotecas vinculadas a aplicações. Diferentes aplicações podem usar diferentes políticas de núcleo. Uma aplicação também pode substituir sua própria biblioteca de thread pelo ambiente de execução Arachne e a política de núcleo do Arachne, enquanto ainda usa o árbitro de núcleo.

[pic 1]

O árbitro de núcleo é um processo de nível de usuário que gerencia núcleos e os aloca para aplicações. Ele coleta informações de cada aplicativo sobre quantos núcleos ele precisa e usa um mecanismo de prioridade simples para dividir os núcleos disponíveis entre as aplicações concorrentes. O árbitro de núcleo ajusta as alocações principais conforme os requisitos do aplicativo mudam.