Integrated: 8289094: [JVMCI] reduce JNI overhead and other VM rounds trips in JVMCI

[Doug Simon]

On Tue, 28 Jun 2022 07:46:09 GMT, Doug Simon <dnsimon at openjdk.org> wrote:

> The interface between HotSpot and libjvmci is implemented via JNI. Every time HotSpot C++ code needs to access libjvmci objects, it requires 4 VM transitions:
> 1. HotSpot: VM to native (`_thread_in_vm` -> `_thread_in_native`)
> 2. SVM: Native to VM (enter SVM)
> 3. SVM: VM to native (exit SVM)
> 4. HotSpot: Native to VM (`_thread_in_native` -> `_thread_in_vm`)
> 
> When processing a `HotSpotCompiledCode` object during code installation (i.e. `CodeInstaller::install`), the overhead of all these transitions is significant.
> This PR changes the way code installation is done by serializing a `HotSpotCompiledCode` object to a byte array (in malloc'ed memory). The C++ code then deserializes this format to install the final code in the code cache. The bulk of this change is in `jdk.vm.ci.hotspot.HotSpotCompiledCodeStream` and `jvmciCodeInstaller.cpp`.
> 
> There are other smaller changes to reduce JNI overhead included in this PR:
> * Pass raw VM values alongside JVMCI wrapper objects to the VM to avoid JNI upcall to unbox in C++. For example, the [getBytecode](https://github.com/openjdk/jdk/blob/33369719b2e39bddd4a1b7f300f36506306b03fa/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java#L125) native method passed a `HotSpotResolvedJavaMethodImpl` to the VM and the VM then subsequently needs a JNI upcall to extract the `Method*` value from the `HotSpotResolvedJavaMethodImpl.methodHandle` field. With PR, `getBytecode` now passes an argument pair (i.e. `getBytecode(HotSpotResolvedJavaMethodImpl method, long methodPointer);`) that removes the unboxing upcall. This is done for all JVMCI objects that wrap a C++ object pointer. The box object is still passed as it protects the validity of the C++ pointer value.
> * Cache HotSpotConstantPool holder in [`HotSpotConstantPool.getHolder()`](https://github.com/openjdk/jdk/blob/33369719b2e39bddd4a1b7f300f36506306b03fa/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotConstantPool.java#L236).
> * Remove VM round trip for converting a `Klass*` value to a `ResolvedJavaType`.
> * Avoid eager `String` creation in `JVMCIEnv::get_jvmci_type`.
> 
> This change is primarily in JVMCI-only code. It has been extensively tested in GraalVM on JDK 17. On the [octane](https://developers.google.com/octane) JavaScript benchmark, this PR reduces total time spent by GraalVM EE in JVMCI code installation from 648 s to 382 s.

This pull request has now been integrated.

Changeset: ba670ecb
Author:    Doug Simon <dnsimon at openjdk.org>
URL:       https://git.openjdk.org/jdk/commit/ba670ecbb9efdbcaa783d4a933499ca191fb58c5
Stats:     4488 lines in 53 files changed: 2492 ins; 992 del; 1004 mod

8289094: [JVMCI] reduce JNI overhead and other VM rounds trips in JVMCI

Reviewed-by: kvn, dlong

-------------

PR: https://git.openjdk.org/jdk/pull/9305