What makes JNI calls slow?

by

First, it’s worth noting that by “slow,” we’re talking about something that can take tens of nanoseconds. For trivial native methods, in 2010 I measured calls at an average 40 ns on my Windows desktop, and 11 ns on my Mac desktop. Unless you’re making many calls, you’re not going to notice.

That said, calling a native method can be slower than making a normal Java method call. Causes include:

  • Native methods will not be inlined by the JVM. Nor will they be just-in-time compiled for this specific machine — they’re already compiled.
  • A Java array may be copied for access in native code, and later copied back. The cost can be linear in the size of the array. I measured JNI copying of a 100,000 array to average about 75 microseconds on my Windows desktop, and 82 microseconds on Mac. Fortunately, direct access may be obtained via GetPrimitiveArrayCritical or NewDirectByteBuffer.
  • If the method is passed an object, or needs to make a callback, then the native method will likely be making its own calls to the JVM. Accessing Java fields, methods and types from the native code requires something similar to reflection. Signatures are specified in strings and queried from the JVM. This is both slow and error-prone.
  • Java Strings are objects, have length and are encoded. Accessing or creating a string may require an O(n) copy.

Some additional discussion, possibly dated, can be found in “Java(tm) Platform Performance: Strategies and Tactics”, 2000, by Steve Wilson and Jeff Kesselman, in section “9.2: Examining JNI costs”. It’s about a third of the way down this page, provided in the comment by @Philip below.

The 2009 IBM developerWorks paper “Best practices for using the Java Native Interface” provides some suggestions on avoiding performance pitfalls with JNI.

More Related Contents:

  1. What is the quantitative overhead of making a JNI call?
  2. In JNI, how do I cache the class, methodID, and fieldIDs per IBM’s performance recommendations?
  3. Performance of java if-else with return statement [duplicate]
  4. Showing the order of growth of the function
  5. Array or List in Java. Which is faster?
  6. java.lang.UnsatisfiedLinkError no *****.dll in java.library.path
  7. Does Java casting introduce overhead? Why?
  8. In java, is it more efficient to use byte or short instead of int and float instead of double?
  9. Technique or utility to minimize Java “warm-up” time?
  10. Counting the number of files in a directory using Java
  11. Performance difference between Java 8 lambdas and anonymous inner classes
  12. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  13. What does a JVM have to do when calling a native method?
  14. Which part of throwing an Exception is expensive?
  15. Java benchmarking – why is the second loop faster?
  16. Why does Java switch on contiguous ints appear to run faster with added cases?
  17. Are volatile variable ‘reads’ as fast as normal reads?
  18. Java Streams: How to do an efficient “distinct and sort”?
  19. Can I call Java from Node.js via JNI and how?
  20. Support for Compressed Strings being Dropped in HotSpot JVM?
  21. Java toString() using reflection?
  22. Fastest way to strip all non-printable characters from a Java String
  23. Generating Java interface with SWIG
  24. Is there a memory-efficient replacement of java.lang.String?
  25. Integer.parseInt(scanner.nextLine()) vs scanner.nextInt()
  26. Attach to already running JVM
  27. Why is the 64bit JVM faster than the 32bit one?
  28. SWIG (v1.3.29) generated C++ to Java Vector class not acting properly
  29. How to use the same C++ code for Android and iOS?
  30. Java Native Interface 32 bit dll on 64 bit system

Leave a Comment