Posso verificar se o compilador C # inlined uma chamada de método?

StackOverflow https://stackoverflow.com/questions/616779

Pergunta

Eu estou escrevendo um jogo XNA onde eu fazer verificações de colisão por pixel. O loop que verifica esse faz isso mudando um int e bit a bit ORing e geralmente é difícil de ler e entender.

Eu gostaria de adicionar métodos privados, tais como private bool IsTransparent(int pixelColorValue) para fazer o loop mais legível, mas eu não quero a sobrecarga de chamadas de método uma vez que este é muito código sensíveis desempenho.

Existe uma maneira de forçar o compilador para inline esta chamada ou eu vou fazer Eu só espero que o compilador vai fazer essa otimização?

Se não houver uma maneira de forçar isso, há uma maneira de verificar se o método foi embutido, falta de leitura da desmontagem? Será que o método mostrar-se na reflexão se fosse embutido e não existem outras chamadas?

Editar:? Eu não posso forçá-lo, então eu posso detectá-lo

Foi útil?

Solução

Não, não pode. Ainda mais, quem decide sobre inlining não é VS compilador que leva você código e converte-lo em IL, mas compilador JIT que leva IL eo converte em código de máquina. Isso ocorre porque somente o compilador JIT sabe o suficiente sobre a arquitetura do processador para decidir se colocar uma linha método é apropriado, pois é uma troca entre pipeline e tamanho de cache.

Assim, mesmo olhando em .NET Reflector não vai ajudá-lo.

Outras dicas

"Você pode verificar System.Reflection.MethodBase.GetCurrentMethod (). Name. Se o método for inline, ele vai devolver o nome do chamador em seu lugar. "

- Joel Coehoorn

Há uma nova maneira de incentivar inlining mais agressivo em .NET 4.5 que é descrito aqui: http://blogs.microsoft.co.il/blogs/sasha/archive/2012/01/20/aggressive -inlining-in-the-clr-4-5-jit.aspx

Basicamente é apenas uma bandeira para dizer ao compilador para linha se possível. Infelizmente, ele não está disponível na versão atual do XNA (Game Studio 4.0), mas devem estar disponíveis quando XNA alcança VS 2012 este ano algum tempo. Já está disponível se você está de alguma forma em execução no Mono. 

[MethodImpl(MethodImplOptions.AggressiveInlining)] 
public static int LargeMethod(int i, int j)
{ 
    if (i + 14 > j) 
    { 
        return i + j; 
    } 
    else if (j * 12 < i) 
    { 
        return 42 + i - j * 7; 
    } 
    else 
    { 
        return i % 14 - j; 
    } 
}

Esteja ciente de que o XBox funciona diferente.

A Google transformou-se o seguinte:

"O método em linha que reduz a sobrecarga de uma chamada de um método. formas JIT em uma linha que satisfaça as seguintes condições.

  • O tamanho do código IL é de 16 bytes ou menos.
  • O comando ramo não é usado (se sentenciar etc.).
  • A variável local não é utilizado.
  • A manipulação de exceção não foi realizado (try, catch, etc.).
  • flutuador não é usado como o argumento ou valor de retorno de um método (provavelmente por o Xbox 360, não aplicada).
  • Quando dois ou mais argumentos estão em um método, que utiliza para a sua vez declarou.

No entanto, uma função virtual não é formado em um inline ".

http: //xnafever.blogspot .com / 2008/07 / inline-método-by-xna-on-xbox360.html

Eu não tenho idéia se ele está correto. Qualquer um?

Não, você não pode.

Basicamente, você não pode fazer isso na maioria dos compiladores modernos C ++ tanto. inline é apenas uma oferta para o compilador. É livre para levá-lo ou não.

O compilador C # não faz qualquer especial inlining no nível IL. JIT otimizador é aquele que vai fazê-lo.

Por que não usar o código inseguro (linha c como seu conhecido) e fazer uso de ponteiros c / c ++ estilo, este é salvo do GC (ou seja, não afetados pela coleta), mas vem com suas próprias implicações de segurança (uso não pode para internet zona de aplicativos), mas é excelente para o tipo de coisa parece que você está tentando alcançar especialmente com o desempenho e ainda mais com matrizes e operações bit a bit?

Para resumir, você quer desempenho para uma pequena parte do seu aplicativo? usar o código inseguro e fazer uso de ponteiros etc parece ser a melhor opção para mim

EDIT: um pouco de fermento? http://msdn.microsoft.com/en-us /library/aa288474(VS.71).aspx

A única maneira de verificar isso é para obter ou escrever um profiler, e gancho para os eventos JIT, você também deve certificar-se Inlining não está desligada, pois é por padrão ao criar o perfil.

Você pode detectá-lo em tempo de execução com a chamada GetCurrentMethod acima mencionado. Mas, isso seria parecem ser um pouco de resíduos [1]. A melhor coisa a fazer seria apenas ILDASM o MSIL e verificar lá.

Note que este é especificamente para o compilador inlining a chamada, e é coberto nos vários docs Reflexão no MSDN.

Se o método que chama o método GetCallingAssembly é expandida em linha pelo compilador (isto é, se o compilador insere o corpo da função para o Microsoft Intermediate Language emitida (MSIL), ao invés de emiti uma chamada de função), então a montagem voltou pelo método GetCallingAssembly é o conjunto que contém o código embutido. Este pode ser diferente do conjunto que contém o método original. Para garantir que um método que chama o método GetCallingAssembly não é inlined pelo compilador, você pode aplicar o atributo MethodImplAttribute com MethodImplOptions.NoInlining.

No entanto, o jitter também é livre para chamadas em linha -. Mas acho que um desmontador seria a única maneira de verificar o que é e não é feito nesse nível

Edit: Só para esclarecer algumas confusões neste segmento, csc.exe irá em linha chamadas MSIL -. embora o jitter (provavelmente) ser mais agressivo nele

[1] e, por resíduos - Quero dizer que (a) que derrota o propósito da inlining (melhor desempenho) por causa da pesquisa de Reflexão. E (b), é provavelmente alterar o comportamento inlining de forma que ele não é mais inline de qualquer maneira. E, antes que você pense que você pode simplesmente ligá-lo Debug constrói com um Assert ou algo -. Perceber que não vai ser embutido durante a depuração, mas pode ser no Release

Existe uma maneira de forçar o compilador para inline esta chamada ou eu vou fazer Eu só espero que o compilador vai fazer essa otimização?

Se é mais barato para inline a função, ele vai. Portanto, não se preocupe com isso a menos que o profiler diz que ele realmente é um problema.

Para obter mais informações

JIT Melhorias no .NET 3.5 SP1

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top