💻 computer science

TENSURE: Fuzzing Sparse Tensor Compilers (Registered Report)

Este artigo apresenta o TENSURE, o primeiro framework de fuzzing de caixa-preta projetado especificamente para testar compiladores de tensores esparsos, utilizando anotação Einsum e um algoritmo de geração baseado em restrições para criar kernels semanticamente válidos e expor falhas críticas de correção em sistemas de ponta como TACO e Finch.

Autores originais: Kabilan Mahathevan, Yining Zhang, Muhammad Ali Gulzar, Kirshanthan Sundararajah

Publicado 2026-03-20

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Kabilan Mahathevan, Yining Zhang, Muhammad Ali Gulzar, Kirshanthan Sundararajah

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você tem uma biblioteca gigante de livros, mas a maioria das páginas está em branco. Em vez de guardar todos os livros ocupando espaço na estante, você decide guardar apenas as páginas com texto, anotando exatamente onde elas ficam. Isso é o que chamamos de dados esparsos (ou "sparse" em inglês). É uma maneira inteligente de economizar espaço e tempo.

Agora, imagine que você precisa de um "cozinheiro" (o Compilador) que pegue essas instruções de "onde estão os livros importantes" e crie uma receita passo a passo para organizar tudo rapidamente. Esse cozinheiro é o Compilador de Tensor Esparsos (STC). Ele é essencial para a inteligência artificial moderna, pois permite que computadores lidem com quantidades massivas de dados sem explodir a memória.

O problema? Esses cozinheiros são complexos e, às vezes, cometem erros silenciosos. Eles podem criar uma receita que parece perfeita, mas que, na hora de cozinhar, queima o bolo ou deixa o sal fora do lugar. E o pior: como os dados são tão irregulares, é muito difícil para os humanos acharem esses erros manualmente.

O que é o TENSURE?

Os autores deste artigo criaram o TENSURE. Pense nele como um robô "caçador de bugs" super inteligente feito especificamente para testar esses cozinheiros de dados esparsos.

Aqui está como ele funciona, usando analogias simples:

1. A Linguagem Universal (Einsum)

Em vez de tentar aprender a linguagem de cada cozinheiro (alguns falam "C++", outros "Julia"), o TENSURE usa uma linguagem universal chamada Einsum.

Analogia: Imagine que você quer pedir uma pizza. Em vez de escrever "peça uma pizza com borda recheada, queijo extra e tomate" para cada pizzaria diferente (o que pode confundir o garçom), você usa um código universal: "Pizza-Modelo-X". O TENSURE gera milhares desses códigos universais complexos para ver se os cozinheiros entendem.

2. O Problema dos Testes Antigos

Os testes antigos tentavam gerar receitas aleatórias, como se alguém estivesse jogando letras no ar para formar palavras.

O Resultado: 97% das vezes, eles geravam "palavras" sem sentido (ex: "abacate-fogo-azul"). O cozinheiro rejeitava a receita imediatamente e o teste falhava. Era um desperdício de tempo.
A Solução do TENSURE: O TENSURE usa um algoritmo de restrições. Ele é como um chef que sabe exatamente quais ingredientes combinam. Ele garante que 100% das receitas que ele cria sejam "comestíveis" (matematicamente válidas) antes mesmo de entregar ao cozinheiro. Isso permite testar muito mais rápido e com mais profundidade.

3. A Técnica do "Espelho Mágico" (Teste Metamórfico)

Como saber se o cozinheiro errou a receita se não temos a resposta certa na mão?

O Truque: O TENSURE usa a lógica da matemática. Se você tem uma receita para fazer uma salada (Alface + Tomate), e você inverte a ordem (Tomate + Alface), o resultado final deve ser exatamente o mesmo.
A Ação: O TENSURE pega uma receita, pede para o cozinheiro fazer. Depois, ele muda a ordem dos ingredientes ou muda a forma como os dados estão guardados (como trocar a caixa de papelão por um saco de plástico, mas mantendo o conteúdo igual) e pede para fazer de novo.
A Detecção: Se o cozinheiro entregar uma salada diferente na segunda tentativa, o TENSURE sabe: "Ei! Você errou algo na cozinha!". Isso é chamado de mutação. O robô explora todas as formas de reorganizar a receita que deveriam dar o mesmo resultado.

O Que Eles Descobriram?

O TENSURE foi testado em dois "cozinheiros" famosos do mundo real: o TACO e o Finch.

O Resultado: O robô encontrou muitos erros. No caso do TACO, mais de 60% dos testes revelaram falhas. Alguns faziam o programa travar (crash), mas o mais perigoso foram os erros silenciosos: o programa rodava, parecia funcionar, mas entregava dados errados.
A Analogia: É como se você pedisse um bolo de chocolate e recebesse um bolo de cenoura que parecia igual por fora, mas tinha um gosto estranho. Se você não provasse com cuidado, nunca saberia. O TENSURE é o "gostador profissional" que descobre que o bolo está errado.

Por que isso importa?

Hoje em dia, a Inteligência Artificial depende desses compiladores para funcionar rápido. Se eles têm bugs, os modelos de IA podem tomar decisões erradas, desde diagnósticos médicos falhos até carros autônomos que não veem obstáculos.

O TENSURE é a primeira ferramenta que consegue "encher" esses compiladores de testes complexos e válidos, garantindo que, quando a IA estiver no mundo real, ela esteja rodando sobre uma base sólida e segura. É como ter um inspetor de qualidade que trabalha 24 horas por dia, provando receitas infinitas para garantir que a cozinha nunca queime o bolo.

1. O Problema

Os Compiladores de Tensores Esparsos (STCs - Sparse Tensor Compilers) tornaram-se infraestrutura crítica para otimizar cargas de trabalho de análise de dados de alta dimensão e aprendizado de máquina. Diferentemente dos tensores densos, os tensores esparsos utilizam formatos de armazenamento comprimido (como CSR, CSC, COO) que exigem que o compilador sintetize automaticamente laços de controle complexos e irregulares a partir de especificações declarativas de alto nível (como a notação Einsum).

O problema central identificado é que os STCs são altamente suscetíveis a defeitos sutis de correção (bugs) devido à complexidade da síntese de controle de fluxo e à necessidade de sincronizar o acesso a múltiplos operandos esparsos. As abordagens de teste existentes falham em validar esses compiladores por três motivos principais:

Incompatibilidade com Grafos de Computação: Ferramentas como NNSmith e PolyJuice baseiam-se em grafos de operadores fixos, o que não consegue testar a capacidade do compilador de sintetizar laços para operações de tensores arbitrárias e não convencionais.
Falta de Consciência Semântica: Fuzzers genéricos baseados em gramática (como Grammarinator) geram uma alta taxa de entradas inválidas (apenas ~3,3% de validade) porque não compreendem as restrições contextuais sensíveis da notação Einsum (ex: consistência dimensional e reutilização de índices).
Fragmentação de Linguagens: A diversidade de DSLs (Linguagens de Domínio Específico) e infraestruturas subjacentes (C++, Julia, MLIR) torna difícil criar um framework de teste unificado.

2. Metodologia

O artigo apresenta o TENSURE, o primeiro framework de fuzzing de caixa-preta extensível projetado especificamente para STCs. A metodologia baseia-se em três pilares principais:

Abstração de Entrada via Einsum: Em vez de usar grafos de operadores fixos, o TENSURE utiliza a notação Einstein Summation (Einsum) como uma abstração de entrada geral. Isso permite a geração de contrações de tensores complexas e não convencionais que expõem casos extremos nas fases de geração de código.
Algoritmo de Geração Baseado em Restrições: Para superar as limitações dos fuzzers de gramática livre, o TENSURE implementa um algoritmo que trata a geração de expressões Einsum como um problema de satisfação de restrições.
- O sistema garante que os índices de saída sejam subconjuntos dos índices de entrada e que os índices de contração apareçam em pelo menos dois tensores.
- Isso assegura 100% de validade semântica das kernels geradas, permitindo que o teste foque nas fases de lowering (tradução para código de baixo nível) em vez de ser rejeitado pelo parser.
Teste Metamórfico sem Referência Confiável: Como não há um compilador de referência "confiável" para comparar, o TENSURE utiliza operadores de mutação que preservam a semântica para criar variantes de programas equivalentes:
1. Comutatividade Algébrica: Permuta a ordem dos operandos (ex: $A \times B$ vs $B \times A$ ), forçando o compilador a gerar diferentes agendamentos de iteração para a mesma operação matemática.
2. Heterogeneidade de Formato de Armazenamento: Atribui aleatoriamente diferentes formatos de armazenamento comprimido (COO, CSR, CSC) aos tensores de entrada e saída. Como a semântica matemática permanece inalterada, qualquer divergência nos resultados indica um defeito na lógica de iteração do compilador para aquele formato específico.
Arquitetura Agnóstica de Linguagem: O sistema utiliza uma camada de abstração JSON para desacoplar a geração de testes da sintaxe específica do compilador alvo, permitindo a integração com diferentes STCs através de tradutores leves.

3. Principais Contribuições

TENSURE: O primeiro framework de fuzzing de caixa-preta agnóstico à linguagem focado na validação funcional de STCs.
Operadores de Mutação Específicos de Domínio: Definição de operadores que exploram a comutatividade algébrica e a heterogeneidade de formatos de armazenamento para gerar variantes semanticamente equivalentes.
Algoritmo de Geração com Garantia de Validade: Formalização de um algoritmo que resolve restrições dimensionais contextuais, superando drasticamente a taxa de validade de fuzzers baseados em gramática (100% vs ~3,3%).

4. Resultados

O TENSURE foi avaliado em dois sistemas de ponta: TACO (baseado em C++) e Finch (baseado em Julia).

Eficiência de Geração: O algoritmo baseado em restrições garantiu 100% de kernels válidos, enquanto o baseline baseado em gramática (Grammarinator) obteve apenas ~3,3% de validade, desperdiçando a maior parte do orçamento de fuzzing em entradas rejeitadas.
Fragilidade do TACO: Em uma campanha de 6 horas com 267.000 iterações, o TENSURE expôs defeitos em aproximadamente 65,2% dos casos aceitos pelo frontend do compilador.
- Destes, 18,6% foram classificados como bugs de código errado (miscompilations silenciosas), onde o compilador gerou código que não falhou, mas produziu resultados incorretos.
- O total de bugs encontrados (crash + erros silenciosos) foi de 5.758.
Fragilidade do Finch: Embora a taxa de iteração fosse menor devido ao tempo de compilação (1.619 iterações), o TENSURE identificou 57 bugs de crash no compilador Finch, validando a extensibilidade do framework para arquiteturas diferentes.
Caso de Estudo: O artigo destaca um bug crítico no TACO onde a inicialização de um rastreador de coordenadas dentro de um laço estava incorreta, levando a resultados errôneos em tensores esparsos, um defeito que passaria despercebido em testes manuais ou de grafos densos.

5. Significado

Este trabalho demonstra que a infraestrutura atual de compilação de tensores esparsos é pervasivamente frágil, especialmente em sistemas que ainda estão em fase de pesquisa ou desenvolvimento (como o TACO).

A importância do TENSURE reside em:

Preencher uma Lacuna Crítica: Oferece a primeira ferramenta automatizada capaz de testar a lógica de síntese de laços de tensores esparsos, uma área anteriormente negligenciada por ferramentas de teste de compiladores densos.
Validação de Segurança e Corretude: A descoberta de "miscompilations silenciosas" é particularmente alarmante, pois esses erros podem corromper resultados de modelos de IA ou simulações científicas sem que o usuário perceba (diferente de um crash que interrompe a execução).
Direcionamento Futuro: O sucesso do TENSURE estabelece a necessidade de ferramentas de teste especializadas para o ecossistema de compilação esparsa, à medida que essas tecnologias migram de protótipos de pesquisa para infraestrutura de produção crítica.

Em suma, o TENSURE prova que a validação de compiladores esparsos requer uma abordagem diferente da usada para compiladores densos, focando na geração de expressões declarativas semanticamente válidas e na exploração sistemática de invariantes algébricas e de formato de dados.