basalt

O problema · Quais GPUs · Como funciona · Início rápido · Medido, não presumido · Descobertas · API · Método · Roteiro · Sala limpa

O problema

Uma instrução de GPU NVIDIA tem 128 bits, e 21 deles não são a instrução. São uma palavra de controle de escalonamento, de stall a reuse: quantos ciclos esperar antes de emitir a próxima instrução, quais scoreboards sinalizar, em quais aguardar e quais operandos podem ser servidos pelo cache de reuso.

O hardware não verifica nada disso. No sm_120 não há intertravamento em instruções de latência fixa. O silício confia em quem quer que tenha produzido a palavra de controle. Se uma contagem de stall for menor que a latência de um valor consumido pela próxima instrução, nada falha, nada trava e nenhum aviso é emitido. A instrução lê um registrador que ainda não foi escrito e calcula sobre dados obsoletos, em velocidade máxima, todas as vezes.

Esse é um tipo estranho de bug. Ele não derruba o programa. Não aparece em um depurador. Produz números apenas errados, o que em uma multiplicação de matrizes ou em um kernel de atenção significa um modelo que treina levemente mal, em vez de um que quebra visivelmente.

As três codificações mais baratas são as quebradas, e nada em lugar nenhum reporta isso. Note também o que a barra à esquerda está fazendo: um stall de zero não é zero ciclos, é uma codificação segura distinta que aguarda resultados pendentes e custa cerca de nove vezes uma instrução escalonada. Um verificador que lesse isso como zero chamaria programas corretos de quebrados.

Ferramentas que geram código de máquina para esta arquitetura atribuem esses bits de controle a partir de um modelo de latência. basalt é a coisa que verifica a resposta.

A verificação que a NVIDIA nunca lançou

A NVIDIA dá a você um compilador que escreve esses 21 bits. Ela não dá nada que os leia de volta e diga que são seguros, e ninguém mais dá.

Montadores para GPUs NVIDIA existem há uma década, a codificação Blackwell foi engenharia reversa antes, existem caracterizações publicadas em nível de ciclo do sm_120, e um montador público para esta arquitetura já atribui os bits de controle de escalonamento ele mesmo e executa seus próprios kernels em uma placa para ver se as respostas saem certas. Tudo verdade, e nada disso é a afirmação:

Nada mais pode receber um cubin que não produziu e ser instruído a dizer se seus bits de controle de escalonamento são seguros.

Seu compilador emitiu aquele cubin, ou uma biblioteca o enviou, ou alguém o escreveu à mão, e até agora não havia como perguntar. Em uma arquitetura sem intertravamento de hardware, essa é a diferença entre "rodou" e "está correto", e a diferença é invisível: um stall um ciclo curto lê um registrador obsoleto e retorna um número errado em velocidade máxima, sem falha e sem aviso, todas as vezes.

Todo o resto aqui existe para tornar essa frase testável. O montador é o que constrói um programa com um stall deliberadamente encurtado. O escalonador é o que força o modelo a se comprometer com uma resposta em vez de avaliar a de outra pessoa. E a auditoria é onde a frase deixa de ser uma ausência e se torna uma medição: basalt apontado para 2.473 cubins sm_120 que a NVIDIA distribui no cuBLAS, cuSOLVER, cuSPARSE, NPP e demais.

Por que não existia, nas próprias palavras do campo. O montador de SASS mais usado diz em sua própria documentação que "verificar o rigor da correção do programa inteiro … [está] longe de ser possível sem suporte oficial. Então, fica para o usuário garantir a correção do programa, com ajuda muito limitada do montador." SIP, sobre autotuning de escalonamentos SASS, afirma que "a validação é impossível para código assembly nativo de GPU porque a semântica formal do sass é fechada."

Ambos tratam da correção semântica: se um kernel calcula o que deveria. basalt não responde isso, e nada aqui afirma responder. Ele responde a uma pergunta estritamente menor, e o ponto é que a pergunta menor é decidível sem a semântica:

Os bits de controle deste programa cobrem suas próprias dependências de dados?

Isso exige a estrutura de dependências, que a codificação entrega, e um modelo de latência, que o silício entrega sob medição. Nenhum dos dois exige saber o que qualquer instrução calcula. Um kernel pode passar nesta verificação e ainda ser o algoritmo errado; o que não pode fazer é ler um registrador antes de o valor chegar.

Segundo, nada mais é medido contra os próprios bytes do fornecedor. A referência do basalt é a saída do ptxas, então uma discordância é bug do basalt até que se prove o contrário. Seu montador tem de reproduzir os 128 bits exatos do compilador. Seu escalonador tem de descartar cada bit de controle que o compilador escolheu, calcular novos e fazer a GPU calcular a mesma resposta.

Um padrão para tudo isso: concordar exatamente com o fornecedor, ou dizer por quê.

E a parte sobre a qual um escalonador costuma ficar calado: o que a correção custa. Os escalonamentos do basalt gastam 1,05x os ciclos de emissão do fornecedor, mais lentos em 111 dos 1.323 pares de kernel e nível de otimização e mais baratos em 842, com todo kernel comparável ainda byte-idêntico na GPU.

A terceira linha é a que mudou as outras três. Um verificador calibrado em um corpus não pode falhar nesse corpus: a folga mais apertada que o compilador foi visto deixar é o piso, por construção, exatamente para o código em que foi medido. Na primeira vez em que este viu código de outro lugar, reportou vinte e seis riscos por kernel em um decodificador JPEG que nunca retornou um pixel errado, e todos os 6.593 eram do basalt. Corrigi-los levou a zero, e zero sobre uma biblioteca também não era evidência: ampliar o conjunto retido para três bibliotecas e 5,2 milhões de instruções levou direto de volta a 940 e encontrou mais cinco erros de modelo, além dos primeiros oito. Treze correções, nenhuma da NVIDIA, e o requisito re-minerado de 24.311 kernels distribuídos colocou um predicado de guarda em 13 ciclos em 229.567 observações, que é o número que a injeção de falhas havia medido nesta placa ao quebrar um programa de propósito. Veja descoberta 32.

Ser mais barato que o fornecedor não é motivo para se vangloriar. o basalt escalona toda dependência na folga mais apertada que ptxas foi visto deixar para exatamente aquele par, e ptxas está equilibrando pressão de registradores e memória junto com latência de emissão enquanto isto otimiza um número. Também não foi acreditado à primeira vista: na primeira vez em que a razão ficou abaixo de 1,0, o round trip de hardware quebrou, e o número só se sustentou depois que o bug que expôs foi corrigido. A razão é fixada dos dois lados na suíte de testes por esse motivo.

A coluna do meio é o ponto. Um verificador e um escalonador que compartilham um modelo de latência concordam entre si enquanto ambos estão errados, então nenhum é evidência para o outro; apenas o silício não tem interesse na discussão. Executar o escalonador sobre sete kernels escritos à mão passou sete de sete por muito tempo. Executá-lo sobre trezentos encontrou quarenta e um errados, e toda correção em descobertas saiu de observar esse número se mover.

O mesmo se aplica às entradas. Uma leitura obsoleta só muda a resposta quando o valor obsoleto e o novo diferem, então um padrão de bytes é uma chance de notar, e executar cada kernel contra um segundo, terceiro e quarto padrões encontrou imediatamente um predicado de carry-out que o modelo de operandos vinha lendo como fonte desde o início. Ele tinha sobrevivido a todos os controles até aquele ponto, incluindo o próprio round trip.

A mesma disciplina decide o que o montador tem permissão de fazer, e vale separar os dois números que ele tem.

A cobertura é de 99,9% do corpus e 87,5% do código de biblioteca distribuído. A correção é de 100%, e é esse o número fixado por um teste. A lacuna entre eles é instruções que o basalt recusa, cada uma nomeando o campo que não conseguiu posicionar, porque uma ferramenta que adivinhasse alcançaria cobertura total emitindo palavras que desmontam para o texto certo e calculam outra coisa. Ele nunca emitiu uma, em 59.760 instruções do corpus e 5.237.448 distribuídas.

Ele só chegou lá após oito rodadas separadas de estar confiantemente incorreto:

• escrever um número de registrador na codificação de uma forma imediata,
• tratar um registrador uniforme como intercambiável com um comum,
• manter o alvo de desvio de qualquer kernel de onde a forma foi colhida,
• colocar o inteiro 15 em um campo que guarda um float de meia precisão,
• escrever um operando em bits que acabaram sendo um sinalizador de reuso,
• escrever em um campo que a sonda havia atribuído apenas parcialmente, deixando o resto ainda codificando o valor antigo,
• espalhar um número de registrador pelo bit que seleciona em qual arquivo de registradores ele está,
• e ler o índice de uma carga constante indexada por registrador como um deslocamento.

Cada um deles produziu uma palavra que monta, desmonta de volta exatamente para o texto de onde veio e calcula outra coisa. Essa é a mesma falha que o resto deste repositório existe para capturar, e é por isso que todos os oito agora são recusados com uma razão nomeando o que o campo realmente guarda, e por que a contagem de instruções que montam para os bytes errados é um teste fixado em zero, em vez de um número em uma tabela.

Uma nona apareceu na primeira vez em que o montador foi apontado para código de máquina que ele não havia produzido, e era de um tipo diferente. c[0x0][UR4] indexa seu deslocamento por um registrador onde a forma registrada guarda um número, e o codificador levantou uma exceção em vez de recusar. Uma falha em entrada estranha é pior do que um veredito errado, porque quem chama não recebe nenhum dos dois.

Quais GPUs

sm_120 não é um número de modelo. É a capacidade de computação compartilhada por toda a linha Blackwell de consumo, então a codificação de instruções, o banco de dados, o montador e o verificador se aplicam a todas as placas dela:

ptxas também tem como alvo sm_121, um chip diferente da mesma família. o basalt nunca rodou em um e não afirma suportá-lo. O que pode dizer é medido: o compilador emite código byte-idêntico, palavras de controle incluídas, para todos os seis alvos que oferece aqui, então o escalonamento de que um kernel precisa é uma propriedade da arquitetura, em vez da peça (descoberta 28). Se isso não fosse verdade, o próprio compilador da NVIDIA estaria emitindo um escalonamento inseguro para um deles.

Todo número medido em silício vem de uma placa física, nomeada exatamente, porque "uma 5070 Ti" não é suficiente para reproduzir uma execução:

Cite o DOI do conceito, 10.5281/zenodo.22072811, em vez de um DOI de versão ou desta URL. Ele resolve para o lançamento mais recente, então permanece correto sem nunca precisar ser editado novamente. O CITATION.cff o contém, portanto já está em ambas as formas acima.

Se você reutilizar as tabelas medidas (src/basalt/data/) ou reproduzir uma figura, cite o lançamento de onde elas vieram em vez de main: os números são regenerados por scripts/verify_all.py em um commit específico, e uma tag é o que torna isso reproduzível.

A atribuição é um termo de licença, não uma cortesia. A Apache-2.0 §4 exige que LICENSE e NOTICE acompanhem qualquer redistribuição ou trabalho derivado, e o NOTICE carrega a autoria e a declaração de clean-room. Forks, cópias vendorizadas e wheels reempacotados mantêm ambos os arquivos.

Autor

Sunny Patel · sunnypatel.net · github.com/sunnypatell