C++ 的性能Java 代码调用与 C# 代码调用

发布于 2024-09-08 22:57:03 字数 260 浏览 5 评论 0原文

我正在为客户探索一种解决方案，我们必须从 C++ 应用程序调用 C# 和 Java 中都可用的 API。我们希望这是一个跨平台应用程序（PC＆Mac），因此Java是首选，但性能更重要。我一直在尝试对 C++ 调用 C# 与 Java 的性能进行一些研究，但尚未找到任何可靠的信息。这个想法是使用 JNI 来调用 Java API 或托管 C++ 来调用 C# API。

有谁知道什么是更好的性能方面的信息或见解吗？这些调用可能会被大量执行，因此数量确实会发挥作用。

谢谢！

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

绿光 2024-09-15 22:57:03

我无法为您提供明确的答案，但我已经完成了 JNI 到 C 库的调用（而不是相反）、.NET 到包装 Java 库的调用以及 .NET 到 .NET 库的调用。我没有关于其中任何一个的官方数据，但是 .NET 到 .NET 的调用，无论是托管 C++ 还是 C# 都是最简单、最快的。因为它们都是 .NET，所以双方都支持一组通用的数据类型。在其他情况下，需要大量丑陋的编组代码来在不同语言的数据类型之间进行转换。 .NET Framework 的设计初衷是让不同 .NET 库之间的调用对其原始语言是透明的，并且它在这方面做得很好。

另一个考虑因素是，在大容量环境中，各个库的性能可能比互操作性能更值得关注。换句话说，如果 Java 库比 C# 库快 25%，那么即使与 C# 的互操作比与 Java 更快、更容易，使用 Java 库也可能是有意义的。

回复收藏 0 原文

盛装女皇 2024-09-15 22:57:03

我假设 C# 和 Java API 是相同的。我曾经在 C# 和 Java 都必须通过互操作/JNI 与同一个 C++ 库对话的环境中工作。就性能而言，Java 版本似乎更加一致，因为 API 非常繁琐并且生成了很多瞬态对象。

这就是我们的调用的样子：

double myDouble= theCPPWrapper.GetField("foo").AsDouble();

theCPPWrapper.GetField(string) 返回一个 JNI Field 类，并且 Field.AsDouble() 方法正在运行毫无意义地通过另一层互操作...

因此 GC 充满了瞬态 Field 对象，并且不知何故 Java 似乎能够更好地应对。

最后的解决方法是将 JNI / Interop api 更改为如下所示：

double myDouble = theCPPWrapper.GetFieldAsDouble("foo"); // no transient Field. Yay!

无论您考虑什么，首先检查您的本机 API 是否没有不必要的麻烦，否则您的 GC 将受到影响。

干杯，
弗洛里安

I assume the C# and Java API are the same. I used to work in an environment where both C# and Java had to talk to the same C++ library through interop / JNI. It seems the Java version was more consistent when it came to performance, as the API was quite chatty and generated a lot of transient objects.

This is what our calls looked like :

double myDouble= theCPPWrapper.GetField("foo").AsDouble();

with theCPPWrapper.GetField(string) returning a JNI Field class and the Field.AsDouble() method going through yet another layer of interop for nothing...

So the GC was full of transient Field objects and somehow Java seemed to cope better.

In the end the fix was to change the JNI / Interop api to look thus :

double myDouble = theCPPWrapper.GetFieldAsDouble("foo"); // no transient Field. Yay!

Whatever you consider, first check that your native API isn't unnecessarily chatty, or your GC will suffer.

Cheers,
Florian

回复收藏 0 原文

别闹i 2024-09-15 22:57:03

我没有 C# 到 Java 的指标。然而，我们在调用 C++ 到 Java 方面拥有丰富的经验。即使您缓存了所有类和方法 ID，速度也非常慢。 C++/JNI 调用似乎需要大约 1000 个时钟周期，我们观察到每秒大约 3M 调用作为限制。因此，我们经历了多次优化迭代，涉及在一次调用中将数据块传输到 Java。此外，您必须检查 Java 异常，或者至少在返回时重置异常状态，这又增加了一点开销。

另一方面，从 Java 调用 C++ 的速度非常快。如果你能做到这一点，那就去做吧。有一些涉及 Java 和 C++ 反转控制的“延续”的高级技术。它是这样的：

C++ -> Java: Start the continuation loop
   Java: while some condition
      Java -> C++: What do you want me to do
      C++: please do this action for me
      Java does the action

这种控制反转并不适合许多（大多数？）应用程序，但它是另一个想法。您还可以考虑各种 RPC 方法，但这些方法也往往会相当缓慢地达到最大值（1M/秒左右）。

I have no metrics for C#-to-Java. However, we have a lot of experience calling C++-to-Java. It is incredibly slow, even after you cache all of your class and method IDs. The C++/JNI call seems to take about 1000 clock cycles, and we observed about 3M calls/second as a limit. Because of this, we've gone through many iterations of optimization involving transporting blocks of data to Java in one call. In addition, you MUST check for Java exceptions or at least reset the exception state upon return, which adds another bit of overhead.

On the other hand, calling C++ from Java is incredibly fast. If you can do that instead, do it. There are some advanced techniques involving "continuations" in which the Java and C++ invert control. It goes like this:

C++ -> Java: Start the continuation loop
   Java: while some condition
      Java -> C++: What do you want me to do
      C++: please do this action for me
      Java does the action

This inversion of control is not suitable for many (most?) applications, but it is another idea. You can also consider various RPC approaches, but these will also tend to max out fairly slowly (1M/second or so).

回复收藏 0 原文