![\"Postagem](\"http:\/\/mig.antlia.com.br\/wp-content\/uploads\/2022\/09\/1-3.png\")
<\/p>\nSegundo postagem no blog oficial da Microsoft em 31 de agosto de 2022, o desenvolvedor Stephen Toub publicou uma atualiza\u00e7\u00e3o de desempenho no .NET 7.<\/p>\n
<\/p>\n
O desempenho \u00e9 o foco principal do desenvolvimento, sejam recursos criados explicitamente para ele ou recursos n\u00e3o relacionados que ainda s\u00e3o projetados e implementados com o desempenho em mente. E agora com a atualiza\u00e7\u00e3o do .NET 7 chegando \u00e9 um bom momento para discutir sobre isso.<\/p>\n
A substitui\u00e7\u00e3o na pilha (OSR) \u00e9 um dos recursos mais interessantes para o .NET 7.<\/p>\n
A ideia por tr\u00e1s \u00e9 que um m\u00e9todo pode ser substitu\u00eddo n\u00e3o apenas entre invoca\u00e7\u00f5es, mas mesmo enquanto est\u00e1 na pilha e em execu\u00e7\u00e3o. Al\u00e9m do c\u00f3digo de camada zero ser instrumentado para contagens de chamadas, os loops s\u00e3o instrumentados para contagens de itera\u00e7\u00e3o. Quando as itera\u00e7\u00f5es ultrapassam um certo limite, o JIT compila uma nova vers\u00e3o altamente otimizada desse m\u00e9todo, transfere todo o estado local\/registro da invoca\u00e7\u00e3o atual para a nova invoca\u00e7\u00e3o e, em seguida, salta para o local apropriado no novo m\u00e9todo.<\/p>\n
Agora no .NET 7, podemos evitar em grande parte as compensa\u00e7\u00f5es entre inicializa\u00e7\u00e3o e taxa de transfer\u00eancia, pois o OSR permite que a compila\u00e7\u00e3o em camadas seja aplicada a todos os m\u00e9todos, mesmo aqueles de longa dura\u00e7\u00e3o. V\u00e1rios PRs foram habilitados para isso, incluindo muitos nos \u00faltimos anos, mas toda a funcionalidade foi desativada nos bits de envio.<\/p>\n
Gra\u00e7as a melhorias como dotnet\/runtime#62831 que implementou suporte para OSR no Arm64 (anteriormente apenas suporte x64 era implementado), e dotnet\/runtime#63406 e dotnet\/runtime#65609 que revisou como as importa\u00e7\u00f5es e ep\u00edlogos OSR s\u00e3o tratados, dotnet\/runtime #65675 habilita OSR e como resultado DOTNET_TC_QuickJitForLoops por padr\u00e3o.<\/p>\n
Foi tamb\u00e9m melhorada a taxa de transfer\u00eancia. Embora a compila\u00e7\u00e3o em camadas tenha sido originalmente concebida como uma forma de otimizar a inicializa\u00e7\u00e3o sem prejudicar a taxa de transfer\u00eancia, ela se tornou muito mais do que isso. H\u00e1 v\u00e1rias coisas que o JIT pode aprender sobre um m\u00e9todo durante o n\u00edvel 0 que pode ser usado para o n\u00edvel 1. Por exemplo, o pr\u00f3prio fato de que o c\u00f3digo de camada 0 executado significa que qualquer m\u00e9todo static acessado pelo m\u00e9todo principal ser\u00e1 inicializado a cada execu\u00e7\u00e3o do c\u00f3digo de camada 1.<\/p>\n
O PGO (Profile-guided optimization) existe h\u00e1 muito tempo, em v\u00e1rias linguagens e compiladores. A ideia b\u00e1sica \u00e9 voc\u00ea compilar seu aplicativo, pedindo ao compilador para injetar instrumenta\u00e7\u00e3o no aplicativo para rastrear v\u00e1rias informa\u00e7\u00f5es interessantes. Em seguida, voc\u00ea coloca seu aplicativo em pr\u00e1tica, executando v\u00e1rios cen\u00e1rios comuns, fazendo com que essa instrumenta\u00e7\u00e3o identifique o que acontece quando o aplicativo \u00e9 executado e os resultados s\u00e3o salvos.<\/p>\n
O aplicativo \u00e9 ent\u00e3o recompilado, alimentando esses resultados de instrumenta\u00e7\u00e3o de volta ao compilador e permitindo que ele otimize o aplicativo exatamente como se espera que seja usado. Essa abordagem ao PGO \u00e9 chamada de \u201cPGO est\u00e1tico\u201d, pois todas as informa\u00e7\u00f5es s\u00e3o coletadas antes da implanta\u00e7\u00e3o real, e \u00e9 algo que o .NET vem fazendo de v\u00e1rias formas h\u00e1 anos.<\/p>\n
O PGO din\u00e2mico aproveita a compila\u00e7\u00e3o em camadas.\u00a0Observei que o JIT instrumenta o c\u00f3digo de camada 0 para rastrear quantas vezes o m\u00e9todo \u00e9 chamado ou, no caso de loops, quantas vezes o loop \u00e9 executado.\u00a0Ele pode instrumentaliz\u00e1-lo para outras coisas tamb\u00e9m.\u00a0Por exemplo, ele pode rastrear exatamente quais tipos concretos s\u00e3o usados \u200b\u200bcomo destino de um despacho de interface e, em seguida, na camada 1, especializar o c\u00f3digo para esperar os tipos mais comuns (isso \u00e9 chamado de \u201cdesvirtualiza\u00e7\u00e3o protegida\u201d ou GDV).\u00a0Voc\u00ea pode ver isso neste pequeno exemplo<\/p>\n
Primeiro, o PGO agora funciona com OSR, gra\u00e7as a melhorias como\u00a0dotnet\/runtime#61453\u00a0.\u00a0Isso \u00e9 um grande neg\u00f3cio, pois significa que m\u00e9todos quentes de longa execu\u00e7\u00e3o que fazem esse tipo de envio de interface (que s\u00e3o bastante comuns) podem obter esses tipos de otimiza\u00e7\u00f5es de desvirtualiza\u00e7\u00e3o\/inlining.\u00a0Em segundo lugar, embora o PGO n\u00e3o esteja atualmente ativado por padr\u00e3o, facilitamos muito a ativa\u00e7\u00e3o.<\/p>\n
Agora \u00e9 poss\u00edvel simplesmente colocar em seu .csproj e ter\u00e1 o mesmo efeito que se voc\u00ea definir antes de cada invoca\u00e7\u00e3o do aplicativo, habilitando o PGO din\u00e2mico. Portanto, se voc\u00ea quiser que a totalidade das bibliotecas principais tamb\u00e9m empregue PGO din\u00e2mico, precisar\u00e1 definir. Em terceiro lugar, no entanto, o PGO din\u00e2mico foi ensinado a instrumentar e otimizar adicionais.<\/p>\n
O PGO j\u00e1 sabia instrumentar o despacho virtual.\u00a0Agora no .NET 7, gra\u00e7as em grande parte ao\u00a0dotnet\/runtime#68703\u00a0, pode fazer isso para delegados (pelo menos para delegados a m\u00e9todos de inst\u00e2ncia).<\/p>\n
Uma das coisas que torna o .NET atraente \u00e9 sua seguran\u00e7a. O tempo de execu\u00e7\u00e3o protege o acesso a arrays, strings e spans de forma que voc\u00ea n\u00e3o possa corromper a mem\u00f3ria acidentalmente ao sair de uma das extremidades. Se voc\u00ea fizer isso, em vez de ler\/escrever mem\u00f3ria arbitr\u00e1ria, voc\u00ea obter\u00e1 exce\u00e7\u00f5es atrav\u00e9s do JIT, inserindo verifica\u00e7\u00f5es de limites toda vez que uma dessas estruturas de dados \u00e9 indexada.<\/p>\n
Sem verifica\u00e7\u00f5es de limites, o que \u00e9 mais facilmente visto pela falta do indicador call no final do m\u00e9todo. Com esta melhoria, o JIT \u00e9 capaz de entender o impacto de certas opera\u00e7\u00f5es de multiplica\u00e7\u00e3o e deslocamento e suas rela\u00e7\u00f5es com os limites da estrutura de dados.<\/p>\n
Com essa melhoria, \u00e9 poss\u00edvel visualizar:<\/p>\n
Foi otimizado igualmente a elimina\u00e7\u00e3o de verifica\u00e7\u00f5es de limites ao lidar com strings constantes e spans inicializados de m\u00e9todos est\u00e1ticos.<\/p>\n
Antes do .NET 5, o Regex do .NET estava praticamente intocado. No .NET 5, foi atualizado para estar no mesmo n\u00edvel ou melhor do que v\u00e1rias outras implementa\u00e7\u00f5es do setor do ponto de vista do desempenho. O .NET 7 d\u00e1 alguns saltos significativos a partir disso.<\/p>\n
Abaixo um exemplo de aplica\u00e7\u00e3o Regex que exibe a seguinte sa\u00edda:<\/p>\n
Duplica ‘This’ na posi\u00e7\u00e3o 0 e duplica ‘a’ na posi\u00e7\u00e3o 66<\/em><\/p>\n [code]<\/p>\n using System; public class Class1 [\/code]<\/p>\n Um dos novos recursos maiores do Regex, foi a nova implementa\u00e7\u00e3o. Na atualiza\u00e7\u00e3o atual \u00e9 poss\u00edvel alternar o processamento para o uso de um novo mecanismo baseado em aut\u00f4matos finitos.<\/p>\n Ele tem dois modos principais de execu\u00e7\u00e3o, um que depende de DFAs (aut\u00f4matos finitos determin\u00edsticos) e outro que depende de NFAs (aut\u00f4matos finitos n\u00e3o determin\u00edsticos). Ambas as implementa\u00e7\u00f5es fornecem uma garantia muito valiosa: o tempo de processamento \u00e9 linear no comprimento da entrada. Considerando que um mecanismo de retrocesso (que \u00e9 o que usa se n\u00e3o for especificado) pode atingir uma situa\u00e7\u00e3o conhecida como \u201cretrocesso catastr\u00f3fico\u201d, onde express\u00f5es complexas combinadas com entradas problem\u00e1ticas podem resultar em processamento exponencial no comprimento da entrada.<\/p>\n O Regex agora s\u00f3 far\u00e1 uma quantidade de trabalho constante amortizada por caractere na entrada. No caso de um DFA, essa constante \u00e9 muito pequena. J\u00e1 em um NFA, essa constante pode ser muito maior, com base na complexidade do padr\u00e3o. De todo modo, para qualquer padr\u00e3o o trabalho ainda \u00e9 linear no comprimento da entrada.<\/p>\n Essa implementa\u00e7\u00e3o \u00e9 baseada na no\u00e7\u00e3o de derivadas de express\u00f5es regulares, um conceito que existe h\u00e1 d\u00e9cadas (o termo foi originalmente cunhado em um artigo de Janusz Brzozowski na d\u00e9cada de 1960) e que foi significativamente avan\u00e7ado para essa implementa\u00e7\u00e3o. As derivadas de Regex formam a base de como os aut\u00f4matos usados \u200b\u200bpara processar a entrada s\u00e3o constru\u00eddos.<\/p>\n A ideia em seu n\u00facleo \u00e9 bastante simples: pegue um Regex e processe um \u00fanico caractere… qual \u00e9 o novo Regex que voc\u00ea obt\u00e9m para descrever o que resta ap\u00f3s o processamento desse caractere? Essa \u00e9 a derivada. Por exemplo, dado o Regex para corresponder a tr\u00eas caracteres de palavra, se voc\u00ea aplicar isso ao pr\u00f3ximo caractere de entrada ‘a’, isso remover\u00e1 o primeiro, deixando-nos com a.<\/p>\n As novas APIs foram habilitadas principalmente porque suportam entradas nos mecanismos Regex .<\/p>\n Na atualiza\u00e7\u00e3o atual, foi disponibilizado Regex para a era baseada em span do .NET, superando uma limita\u00e7\u00e3o significativa Regex desde que os spans foram introduzidos no .NET Core 2.1. Regex tem sido historicamente baseado no processamento de entradas e esse fato permeia o design e a implementa\u00e7\u00e3o, incluindo as APIs expostas para o modelo de extensibilidade usado no .NET Framework ( agora est\u00e1 obsoleto e nunca foi funcional no .NET Core).<\/p>\n Uma sutileza que depende da natureza da entrada \u00e9 como as informa\u00e7\u00f5es de correspond\u00eancia s\u00e3o retornadas aos chamadores. Retorna um objeto que representa a primeira correspond\u00eancia na entrada e esse objeto exp\u00f5e um m\u00e9todo que permite mover para a pr\u00f3xima correspond\u00eancia. Isso significa que o objeto precisa armazenar uma refer\u00eancia \u00e0 entrada para que possa ser realimentado no mecanismo correspondente como parte de tal chamada.<\/p>\n Todos os mecanismos Regex dependem de uma classe base que armazena nele todo o estado necess\u00e1rio para alimentar os m\u00e9todos e que comp\u00f5em a l\u00f3gica de correspond\u00eancia real para as express\u00f5es regulares (esses m\u00e9todos cont\u00eam todo o c\u00f3digo principal para realizar a correspond\u00eancia).<\/p>\n Uma otimiza\u00e7\u00e3o ocorreu para pular posi\u00e7\u00f5es de entrada anteriores que n\u00e3o poderiam iniciar uma correspond\u00eancia.<\/p>\n Foi adicionado um novo m\u00e9todo virtual chamado Scanque. Este n\u00e3o precisa mais acessar os membros protegidos. Agora com o m\u00e9todo ativo \u00e9 poss\u00edvel apenas receber o span, j\u00e1 fatiado para a regi\u00e3o de entrada e, consequentemente s\u00e3o processadas as entradas.<\/p>\n Uma das coisas legais sobre isso, do ponto de vista do desempenho, \u00e9 que permite que o JIT fa\u00e7a um trabalho melhor ao reduzir v\u00e1rias despesas gerais, principalmente em torno da verifica\u00e7\u00e3o de limites. Quando a l\u00f3gica \u00e9 implementada em termos de string de entrada, o mecanismo tamb\u00e9m recebe o in\u00edcio e o fim da regi\u00e3o da entrada a ser processada (j\u00e1 que o desenvolvedor poderia ter chamado um m\u00e9todo para processar apenas uma substring). Obviamente, a l\u00f3gica de correspond\u00eancia do mecanismo \u00e9 muito mais complicada do que isso, mas, simplificando, imagine que a totalidade do mecanismo fosse apenas um loop sobre a entrada.<\/p>\n A manipula\u00e7\u00e3o de loops foi significativamente aprimorada, tanto no que diz respeito a process\u00e1-los mais rapidamente quanto no que diz respeito ao menor retrocesso.<\/p>\n Com os loops h\u00e1 duas principais melhorias:<\/p>\n
\nusing System.Text.RegularExpressions;<\/p>\n
\n{
\npublic static void Main()
\n{
\nstring pattern = @"\\b(\\w+?)\\s\\1\\b";
\nstring input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
\nforeach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
\nConsole.WriteLine("{0} (duplicates ‘{1}’) at position {2}",
\nmatch.Value, match.Groups[1].Value, match.Index);
\n}
\n}
\n\/\/ The example displays the following output:
\n\/\/ This this (duplicates ‘This’) at position 0
\n\/\/ a a (duplicates ‘a’) at position 66<\/p>\nNovas APIs<\/h3>\n
Loops e retrocessos<\/h3>\n