Geração de Código Nativo

Com o suporte do Luau para a geração de código nativo, scripts do lado do servidor em sua experiência podem ser compilados diretamente nas instruções de código da máquina que osCPUs executam, em vez de código de bytes regular que o Luau VM opera. Essa função pode ser usada para melhorar a velocidade de execução para alguns scripts no servidor, especialmente aqueles que têm muito cálculo de números sem usar muito tempo de biblioteca Luau ou chamadas de API Roblox.

Habilitando Nativo

Para habilitar a geração de código nativo para um Script, adicione o --!native comentário na parte superior:¹

--! nativo

print("Hello from native code!")

Isso habilita a geração de código nativo para todas as funções no script e o alcance de nível superior, se for considerado rentável. Nenhuma alteração adicional é necessária; o comportamento da geração de scripts nativamente é exatamente o mesmo que antes e apenas o desempenho é diferente. Todos os recursos do idioma Luau e todas as APIs Roblox são suportados.

Alternativamente, você pode habilitar a geração de código nativo para uma função individual adicionando o atributo @native:

@native
local function f(x)
  return (x + 1)
end

Melhores Práticas

As seguintes dicas ajudarão você a se beneficiar mais da geração de código nativo:

• É melhor habilitar esse recurso dentro de scripts que executam muitas operações de cálculo diretamente dentro do Luau. Se você tiver muitas operações de cálculo em tabelas e, especialmente, buffer tipos, o script pode ser um bom candidato.

• Apenas as funções do script são compiladas nativamente. O código no topo exterior é executado apenas uma vez e muitas vezes não é tão benéfico quanto funções que são chamadas muitas vezes, especialmente aquelas que são chamadas a cada quadro.

• Recomenda-se que você medra o tempo que um script ou uma função leva com e sem compilação nativa para julgar quando é melhor usá-lo. A ferramenta Script Profiler pode medir o desempenho de funções para tomar decisões informadas.

• Pode ser tentador colocar o comentário --!native em todos os scripts apenas em caso de alguns deles serem executados mais rápido, mas a geração de código nativo tem alguns defeitos:

  • O tempo de compilação de código é necessário, o que pode aumentar o tempo de inicialização dos servidores.
  • Memória extra é ocupada para armazenar código compilado nativamente.
  • Há um limite na quantidade total de código nativamente compilado em uma experiência.

Esses problemas podem ser abordados com o uso judicial do atributo @native.

Código para Evitar

Embora todos os recursos se comportem da mesma maneira com ou sem a geração de código nativo ativada, alguns deles não serão executados nativamente e podem causar desotimização ou um retorno de chamada interpretado. Esses incluem:

• Use de deprecado getfenv() / setfenv() chamadas.
• Use de várias funções incorporadas Luau, como math.asin() com argumentos não numéricos.
• Passing parameters mal escritos para funções, por exemplo, chamando foo quando function foo(arg: string) é declarado como 1> function foo(arg: string / cadeia / texto)1> . Lembre-se de sempre usar as anotações de tipo corretas 4> type annotations4> .

Ao usar o Script Profiler, você pode comparar o tempo levar por uma versão regular da função contra a que é compilada nativamente. Se uma função dentro de um script de script de --!native 2> ou marcado com2> 5> --!native5> , não parece estar executando nativamente, um ou mais fatores da lista acima pode estar desencadeando a de-ótima.

Usando Anotações de Tipo

A geração de código nativo tenta inferir o tipo mais provável para uma variável dada para otimizar os caminhos de código. Por exemplo, é assumido que a + b``t.X ou que uma t

Embora a geração de código nativo suporte qualquer digitar, previsões podem acionar cheques desnecessários, resultando em execução de código mais lenta.

Para resolver alguns problemas comuns, Luau verifica as anotações de função, mas recomenda especialmente anotar Vector3 argumentos:

--! nativo

-- '' v ''é assumido ser uma tabela; função desempenha mais lentamente devido a verificações de tabela
local function sumComponentsSlow(v)
	return v.X + v.Y + v.Z
end

-- “v” é declarado um Vector3; código especializado para véctores é gerado
local function sumComponentsFast(v: Vector3)
	return v.X + v.Y + v.Z
end

Studio Tooling

A seguinte ferramenta do Studio é compatível com --!native scripts e funções #number1.

Depuração

O modo geral de debug de scripts é suportado, mas as visualizações para locais/upvalues podem estar incompletas e faltando variáveis de chamada de estaca que estão executando nativamente.

Nota também que ao debugar código selecionado para compilação nativa, colocar pontos de interrupção desativará a execução nativa para essas funções.

Perfilador de Script

No Script Profiler, funções executando nativamente exibem <native> ao lado deles:

Se uma função marcada @native ou dentro de um script de --!native . não mostra a anotação 1> < native>1> , que função pode não estar sendo executada nativamente devido a 4> pontos de interrupção4> de colocação, uso de 7>código desencorajado

Pilha Luau

No Luau Heap profiler, memory taken by native functions displays as [native] elements in the graph.

Análise de Tamanho

Cada script nativamente compactado consome memória. Quando o tamanho do código compactado atinge um limite predefinido, a compilação nativa paraça e o código restante é executado não nativamente. Isso torna essencial escolher scripts com cuidado para a compilação nativa.

Para monitorar o tamanho do código nativo de funções e scripts individuais:

1. Verifique se você está em Servidor visão através do botão botão cliente/servidor.
2. Invoca debug.dumpcodesize() da Barra de Comandos.

Na janela Saída, você verá o número total de scripts e funções que foram compilados nativamente até o ponto de invocação, a memória consumida pelo seu código nativo e o limite de tamanho do código nativo. Seguindo o resumo, você verá uma tabela para cada script nativo compilado em ordem crescente de tamanho do código.

Para cada script, a saída exibe o número de funções compiladas e a memória de código nativo. Cada função é então listada em ordem decrescente de tamanho do código nativo, com funções anônimas mostradas como [anonymous] e códigos inteiros mostrados como [top level]. Na coluna final, o percentual é calculado com relação ao tamanho

Limites e Troubleshooting

Compilar código em instruções para um determinado CPU requer memória adicional. Além disso, otimizações para funções complexas podem levar muito tempo para serem executadas. Atingir um limite interno relatará um erro na janela Saída do Studio, incluindo: