Considerações sobre desempenho para interoperabilidade (C++)
Este tópico fornece diretrizes para reduzir o efeito de transições de interoperabilidade gerenciado/desempenho em tempo de execução.
Visual C++ oferece suporte os mesmos mecanismos de interoperabilidade que outras.NET linguagens como, por exemplo, Visual Basic e C# (P/Invoke), mas ele também fornece suporte de interoperabilidade que é específico para o Visual C++ (interoperabilidade de C++). Para aplicativos críticos de desempenho, é importante compreender as implicações de desempenho de cada técnica de interoperabilidade.
Independentemente da interoperabilidade técnica usada, seqüências de transição especial, chamadas thunks, são necessárias sempre que uma função gerenciada chama um não gerenciado função e o vice versa. Estes thunks são inseridos automaticamente pelo compilador Visual C++, mas é importante ter em mente que cumulativamente, essas transições podem ser caras em termos de desempenho.
Reduzindo as transições
Uma maneira de evitar ou reduzir o custo de thunks de interoperabilidade é Refatorar interfaces envolvidas minimizar as transições gerenciados/não gerenciados. Melhorias drásticas no desempenho podem ser feitas por interfaces informais, o que são aqueles envolvidos chamadas freqüentes entre o limite gerenciado/de direcionamento. Uma função gerenciada que chama uma função não gerenciada em um loop estreito, por exemplo, é um bom candidato para refatoração. Se o próprio loop é movido para o lado de não gerenciado ou se uma alternativa gerenciada para a chamada não gerenciada é criada (talvez ser dados de enfileiramento de mensagens no lado gerenciado e empacotamento para a API não gerenciada ao mesmo tempo após o loop), o número de transições pode ser reduzido significativamente.
P/Invoke vs.Interoperabilidade de C++
Para.NET linguagens, como, por exemplo, Visual Basic e C#, o método prescrito para interoperar com componentes nativos é P/Invoke. Porque P/Invoke é suportada pela.NET Framework, Visual C++ suporta bem, mas o Visual C++ também fornece seu próprio suporte de interoperabilidade, que é chamado de interoperabilidade de C++. Interoperabilidade de C++ é preferível P/Invoke porque P/Invoke não é do tipo seguro. Como resultado, principalmente são relatados erros em tempo de execução, mas o C++ Interop também tem vantagens de desempenho em P/Invoke.
Ambas as técnicas requerem várias coisas aconteça sempre que uma função gerenciada chama uma função não gerenciada:
Os argumentos de chamada de função são empacotados do CLR para tipos nativos.
Uma conversão de não gerenciado a gerenciado é executada.
A função não gerenciada é chamada (usando as versões nativas dos argumentos).
Uma conversão de não gerenciado para gerenciado é executado.
O tipo de retorno e qualquer "out" ou "in, out" argumentos são empacotados de nativo para tipos CLR.
Os thunks gerenciados/não são necessárias para a interoperabilidade funcione em todos os, mas o empacotamento de dados que é necessário depende dos tipos de dados envolvidos, a assinatura de função e como os dados serão usados.
O empacotamento de dados realizado por interoperabilidade de C++ é a forma mais simples possível: os parâmetros são simplesmente copiados entre o limite gerenciado/de maneira bit a bit; Nenhuma transformação é realizada em todos os. P/Invoke, isso só é true se todos os parâmetros são simples, tipos blittable. Caso contrário, P/Invoke realiza etapas muito eficientes para converter cada parâmetro gerenciado para um tipo nativo apropriado e vice-versa, se os argumentos são marcados como "out" ou "in, out".
Em outras palavras, a interoperabilidade de C++ usa o método mais rápido possível de empacotamento de dados, enquanto o P/Invoke usa o método mais robusto. Isso significa que a interoperabilidade C++ (em uma forma típica para C++) fornece o desempenho ideal por padrão e o programador é responsável pelo endereçamento casos em que esse comportamento não é segura ou apropriada.
Interoperabilidade de C++, portanto, requer que o empacotamento de dados deve ser fornecido explicitamente, mas a vantagem é que o programador é livre para decidir o que é apropriado, dada a natureza dos dados e como ele será usado. Além disso, embora o comportamento de empacotamento de dados de P/Invoke pode ser modificado no personalizada para um grau, interoperabilidade de C++ permite que os dados de empacotamento para serem personalizados em uma base por chamada. Isso não é possível com P/Invoke.
Para obter mais informações sobre interoperabilidade de C++, consulte Usar a interoperabilidade de C++ (PInvoke implícito).