Mecanismo de execução nativo para o Fabric Spark

O mecanismo de execução nativo é um aprimoramento inovador para execuções de trabalho do Apache Spark no Microsoft Fabric. Esse mecanismo vetorizado otimiza o desempenho e a eficiência de suas consultas Spark, executando-as diretamente em sua infraestrutura lakehouse. A integração perfeita do mecanismo significa que ele não requer modificações de código e evita a dependência do fornecedor. Ele suporta APIs do Apache Spark e é compatível com Runtime 1.2 (Spark 3.4) e Runtime 1.3 (Spark 3.5), e funciona com os formatos Parquet e Delta. Independentemente da localização dos seus dados no OneLake, ou se você acessar os dados por meio de atalhos, o mecanismo de execução nativo maximiza a eficiência e o desempenho.

O mecanismo de execução nativo eleva significativamente o desempenho da consulta enquanto minimiza os custos operacionais. Ele oferece um notável aumento de velocidade, alcançando um desempenho até quatro vezes mais rápido em comparação com o OSS (software de código aberto) tradicional Spark, conforme validado pelo benchmark TPC-DS de 1TB. O mecanismo é hábil em gerenciar uma ampla gama de cenários de processamento de dados, desde ingestão de dados de rotina, trabalhos em lote e tarefas ETL (extrair, transformar, carregar), até análises complexas de ciência de dados e consultas interativas responsivas. Os usuários se beneficiam de tempos de processamento acelerados, maior taxa de transferência e utilização otimizada de recursos.

O Native Execution Engine é baseado em dois componentes OSS principais: Velox, uma biblioteca de aceleração de banco de dados C++ introduzida pela Meta, e Apache Gluten (incubação), uma camada intermediária responsável por descarregar a execução de mecanismos SQL baseados em JVM para mecanismos nativos introduzidos pela Intel.

Quando usar o mecanismo de execução nativo

O mecanismo de execução nativo oferece uma solução para executar consultas em conjuntos de dados de grande escala; ele otimiza o desempenho usando os recursos nativos das fontes de dados subjacentes e minimizando a sobrecarga normalmente associada à movimentação e serialização de dados em ambientes Spark tradicionais. O mecanismo suporta vários operadores e tipos de dados, incluindo agregação de hash rollup, junção de loop aninhado de difusão (BNLJ) e formatos precisos de carimbo de data/hora. No entanto, para se beneficiar totalmente dos recursos do mecanismo, você deve considerar seus casos de uso ideais:

• O mecanismo é eficaz ao trabalhar com dados nos formatos Parquet e Delta, que pode processar de forma nativa e eficiente.
• As consultas que envolvem transformações e agregações complexas se beneficiam significativamente dos recursos de processamento colunar e vetorização do mecanismo.
• O aprimoramento do desempenho é mais notável em cenários em que as consultas não acionam o mecanismo de fallback, evitando recursos ou expressões sem suporte.
• O mecanismo é adequado para consultas que são computacionalmente intensivas, em vez de simples ou ligadas a E/S.

Para obter informações sobre os operadores e funções suportados pelo mecanismo de execução nativo, consulte a documentação do Apache Gluten.

Habilite o mecanismo de execução nativo

Para usar todos os recursos do mecanismo de execução nativo durante a fase de visualização, configurações específicas são necessárias. Os procedimentos a seguir mostram como ativar esse recurso para blocos de anotações, definições de trabalho do Spark e ambientes inteiros.

Habilitar no nível do ambiente

Para garantir um aprimoramento uniforme do desempenho, habilite o mecanismo de execução nativo em todos os trabalhos e blocos de anotações associados ao seu ambiente:

1. Navegue até as configurações do ambiente.

2. Vá para Computação do Spark.

3. Vá para a guia Aceleração .

4. Marque a caixa Ativar mecanismo de execução nativo.

5. Salve e publique as alterações.

   

Quando habilitado no nível do ambiente, todos os trabalhos e blocos de anotações subsequentes herdam a configuração. Essa herança garante que quaisquer novas sessões ou recursos criados no ambiente se beneficiem automaticamente dos recursos de execução aprimorados.

Habilitar para uma definição de trabalho do bloco de anotações ou do Spark

Para habilitar o mecanismo de execução nativo para um único bloco de anotações ou definição de trabalho do Spark, você deve incorporar as configurações necessárias no início do script de execução:

%%configure 
{ 
   "conf": {
       "spark.native.enabled": "true", 
       "spark.shuffle.manager": "org.apache.spark.shuffle.sort.ColumnarShuffleManager" 
   } 
} 

Para blocos de anotações, insira os comandos de configuração necessários na primeira célula. Para definições de trabalho do Spark, inclua as configurações na linha de frente da definição de trabalho do Spark.

O Native Execution Engine é integrado com pools ao vivo, portanto, uma vez que você habilite o recurso, ele entra em vigor imediatamente sem exigir que você inicie uma nova sessão.

Controle no nível de consulta

Os mecanismos para habilitar o Native Execution Engine nos níveis de locatário, espaço de trabalho e ambiente, perfeitamente integrados à interface do usuário, estão em desenvolvimento ativo. Enquanto isso, você pode desativar o mecanismo de execução nativo para consultas específicas, especialmente se elas envolverem operadores que não são suportados no momento (consulte limitações). Para desativar, defina a configuração do Spark spark.native.enabled como false para a célula específica que contém sua consulta.

%%sql 
SET spark.native.enabled=FALSE; 

%%pyspark
spark.conf.set('spark.native.enabled', 'false')   

%%spark  
spark.conf.set("spark.native.enabled", "false")   

%%sparkr
library(SparkR)
sparkR.conf("spark.native.enabled", "false")

Depois de executar a consulta na qual o mecanismo de execução nativo está desativado, você deve reativá-lo para as células subsequentes definindo spark.native.enabled como true. Esta etapa é necessária porque o Spark executa células de código sequencialmente.

%%sql 
SET spark.native.enabled=TRUE; 

%%pyspark
spark.conf.set('spark.native.enabled', 'true')   

%%spark  
spark.conf.set("spark.native.enabled", "true")   

%%sparkr
library(SparkR)
sparkR.conf("spark.native.enabled", "true")

Identificar as operações executadas pelo motor

Há vários métodos para determinar se um operador em seu trabalho do Apache Spark foi processado usando o mecanismo de execução nativo.

Interface do usuário do Spark e servidor de histórico do Spark

Acesse a interface do usuário do Spark ou o servidor de histórico do Spark para localizar a consulta que você precisa inspecionar. No plano de consulta exibido na interface, procure por nomes de nó que terminem com o sufixo Transformer, NativeFileScan ou VeloxColumnarToRowExec. O sufixo indica que o mecanismo de execução nativo executou a operação. Por exemplo, os nós podem ser rotulados como RollUpHashAggregateTransformer, ProjectExecTransformer, BroadcastHashJoinExecTransformer, ShuffledHashJoinExecTransformer ou BroadcastNestedLoopJoinExecTransformer.

DataFrame explicar

Como alternativa, você pode executar o df.explain() comando em seu bloco de anotações para exibir o plano de execução. Na saída, procure os mesmos sufixos Transformer, NativeFileScan ou VeloxColumnarToRowExec . Esse método fornece uma maneira rápida de confirmar se operações específicas estão sendo manipuladas pelo mecanismo de execução nativo.

Mecanismo de fallback

Em alguns casos, o mecanismo de execução nativo pode não ser capaz de executar uma consulta devido a razões como recursos sem suporte. Nestes casos, a operação recai sobre o motor Spark tradicional. Esse mecanismo de fallback garante que não haja interrupção no seu fluxo de trabalho.

Monitorar consultas e DataFrames executados pelo mecanismo

Para entender melhor como o mecanismo de execução nativa é aplicado a consultas SQL e operações DataFrame, e para detalhar os níveis de estágio e operador, você pode consultar a interface do usuário do Spark e o Spark History Server para obter informações mais detalhadas sobre a execução do mecanismo nativo.

Guia Mecanismo de Execução Nativa

Você pode navegar até a nova guia 'Gluten SQL / DataFrame' para visualizar as informações de compilação do Gluten e os detalhes de execução da consulta. A tabela Consultas fornece informações sobre o número de nós em execução no mecanismo nativo e aqueles que retornam à JVM para cada consulta.

Gráfico de execução de consulta

Você também pode clicar na descrição da consulta para a visualização do plano de execução da consulta Apache Spark. O gráfico de execução fornece detalhes de execução nativos em todos os estágios e suas respetivas operações. As cores de plano de fundo diferenciam os mecanismos de execução: o verde representa o Mecanismo de Execução Nativo, enquanto o azul claro indica que a operação está sendo executada no Mecanismo JVM padrão.

Limitações

Embora o mecanismo de execução nativo melhore o desempenho para trabalhos do Apache Spark, observe suas limitações atuais.

• Algumas operações específicas do Delta não são suportadas (ainda), incluindo operações de mesclagem, verificações de pontos de verificação e vetores de exclusão.
• Certos recursos e expressões do Spark não são compatíveis com o mecanismo de execução nativo, como funções definidas pelo usuário (UDFs) e a array_contains função, bem como streaming estruturado do Spark. O uso dessas operações ou funções incompatíveis como parte de uma biblioteca importada também causará fallback para o mecanismo Spark.
• Não há suporte para verificações de soluções de armazenamento que utilizam endpoints privados.
• O mecanismo não suporta o modo ANSI, então ele pesquisa, e uma vez que o modo ANSI está ativado, ele cai de volta para vanilla Spark.

Ao usar filtros de data em consultas, é essencial garantir que os tipos de dados em ambos os lados da comparação correspondam para evitar problemas de desempenho. Tipos de dados incompatíveis podem não trazer impulso de execução de consulta e podem exigir transmissão explícita. Certifique-se sempre de que os tipos de dados do lado esquerdo (LHS) e do lado direito (RHS) de uma comparação são idênticos, pois os tipos incompatíveis nem sempre serão automaticamente lançados. Se uma incompatibilidade de tipo for inevitável, use a transmissão explícita para corresponder aos tipos de dados, como CAST(order_date AS DATE) = '2024-05-20'. Consultas com tipos de dados incompatíveis que exigem transmissão não serão aceleradas pelo Native Execution Engine, portanto, garantir a consistência do tipo é crucial para manter o desempenho. Por exemplo, em vez de onde order_date está e a cadeia de caracteres é DATE, explicitamente convertido order_date para DATE garantir tipos de order_date = '2024-05-20' dados consistentes e melhorar o DATETIME desempenho.

Conteúdos relacionados

• Tempos de execução do Apache Spark na malha
• O que é o autotune para configurações do Apache Spark no Fabric?