Skip to content

Commit 0cd6f93

Browse files
dougxcdougxc
committed
tmp4
1 parent a29ad74 commit 0cd6f93

File tree

22 files changed

+377
-552
lines changed

22 files changed

+377
-552
lines changed

‎compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/VerifyLibGraalContextChecks.java

-1
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,6 @@
4444
* {@link jdk.graal.compiler.serviceprovider.GraalServices}. All other code must use one of the
4545
* following methods:
4646
* <ul>
47-
* <li>{@link GraalServices#isBuildingLibgraal()}</li>
4847
* <li>{@link GraalServices#isInLibgraal()}</li>
4948
* <li>{@link ImageInfo#inImageCode()}</li>
5049
* <li>{@link ImageInfo#inImageBuildtimeCode()}</li>

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/GraalServiceThread.java

+10-15
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,8 @@
2525
package jdk.graal.compiler.core;
2626

2727
import jdk.graal.compiler.serviceprovider.GraalServices;
28+
import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;
29+
import org.graalvm.nativeimage.ImageInfo;
2830

2931
/**
3032
* This is a utility class for Threads started by the compiler itself. In certain execution
@@ -42,7 +44,11 @@ public GraalServiceThread(String name, Runnable runnable) {
4244
@Override
4345
public final void run() {
4446
try {
45-
beforeRun();
47+
if (ImageInfo.inImageRuntimeCode()) {
48+
if (!HotSpotJVMCIRuntime.runtime().attachCurrentThread(isDaemon(), null)) {
49+
throw new InternalError("Couldn't attach to HotSpot runtime");
50+
}
51+
}
4652
} catch (InternalError t) {
4753
// There was a problem attaching this thread to the libgraal peer runtime.
4854
// Not much that can be done apart from terminating the thread.
@@ -52,7 +58,9 @@ public final void run() {
5258
try {
5359
runnable.run();
5460
} finally {
55-
afterRun();
61+
if (ImageInfo.inImageRuntimeCode()) {
62+
HotSpotJVMCIRuntime.runtime().detachCurrentThread(false);
63+
}
5664
}
5765
}
5866

@@ -70,17 +78,4 @@ protected void onAttachError(InternalError error) {
7078
}
7179
}
7280

73-
/**
74-
* Substituted by {@code Target_jdk_graal_compiler_core_GraalServiceThread} to attach to the
75-
* peer runtime if required.
76-
*/
77-
private void afterRun() {
78-
}
79-
80-
/**
81-
* Substituted by {@code Target_jdk_graal_compiler_core_GraalServiceThread} to attach to the
82-
* peer runtime if required.
83-
*/
84-
private void beforeRun() {
85-
}
8681
}

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotGraalCompiler.java

+45-3
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,7 @@
4646
import jdk.graal.compiler.hotspot.meta.HotSpotProviders;
4747
import jdk.graal.compiler.hotspot.phases.OnStackReplacementPhase;
4848
import jdk.graal.compiler.java.GraphBuilderPhase;
49+
import jdk.graal.compiler.libgraal.LibGraalJNIMethodScope;
4950
import jdk.graal.compiler.lir.asm.CompilationResultBuilderFactory;
5051
import jdk.graal.compiler.lir.phases.LIRSuites;
5152
import jdk.graal.compiler.nodes.Cancellable;
@@ -63,7 +64,7 @@
6364
import jdk.graal.compiler.phases.tiers.Suites;
6465
import jdk.graal.compiler.printer.GraalDebugHandlersFactory;
6566
import jdk.graal.compiler.serviceprovider.GlobalAtomicLong;
66-
import jdk.graal.compiler.serviceprovider.VMSupport;
67+
import jdk.graal.compiler.word.Word;
6768
import jdk.graal.nativeimage.LibGraalRuntime;
6869
import jdk.internal.misc.Unsafe;
6970
import jdk.vm.ci.code.CompilationRequest;
@@ -78,6 +79,8 @@
7879
import jdk.vm.ci.meta.SpeculationLog;
7980
import jdk.vm.ci.meta.TriState;
8081
import jdk.vm.ci.runtime.JVMCICompiler;
82+
import org.graalvm.jniutils.JNI;
83+
import org.graalvm.jniutils.JNIMethodScope;
8184
import org.graalvm.nativeimage.ImageInfo;
8285

8386
public class HotSpotGraalCompiler implements GraalJVMCICompiler, Cancellable, JVMCICompilerShadow, GraalCompiler.RequestedCrashHandler {
@@ -126,10 +129,49 @@ public HotSpotGraalRuntimeProvider getGraalRuntime() {
126129
return graalRuntime;
127130
}
128131

132+
/**
133+
* Performs the following actions around a libgraal compilation:
134+
* <ul>
135+
* <li>before: opens a JNIMethodScope to allow Graal compilations of Truffle host methods to
136+
* call methods on the TruffleCompilerRuntime.</li>
137+
* <li>after: closes the above JNIMethodScope</li>
138+
* <li>after: triggers GC weak reference processing as SVM does not use a separate thread for
139+
* this in libgraal</li>
140+
* </ul>
141+
*/
142+
static class LibGraalCompilationRequestScope implements AutoCloseable {
143+
final JNIMethodScope scope;
144+
145+
LibGraalCompilationRequestScope() {
146+
JNI.JNIEnv env = Word.unsigned(HotSpotGraalRuntime.getJNIEnv());
147+
/*
148+
* This scope is required to allow Graal compilations of host methods to call methods in
149+
* the TruffleCompilerRuntime. This is, for example, required to find out about
150+
* Truffle-specific method annotations.
151+
*/
152+
scope = LibGraalJNIMethodScope.open("<called from VM>", env, false);
153+
}
154+
155+
@Override
156+
public void close() {
157+
try {
158+
if (scope != null) {
159+
scope.close();
160+
}
161+
} finally {
162+
/*
163+
* libgraal doesn't use a dedicated reference handler thread, so trigger the
164+
* reference handling manually when a compilation finishes.
165+
*/
166+
HotSpotGraalRuntime.doReferenceHandling();
167+
}
168+
}
169+
}
170+
129171
@SuppressWarnings("try")
130172
@Override
131173
public CompilationRequestResult compileMethod(CompilationRequest request) {
132-
try (AutoCloseable ignored = VMSupport.getCompilationRequestScope()) {
174+
try (AutoCloseable ignored = new LibGraalCompilationRequestScope()) {
133175
return compileMethod(request, true, getGraalRuntime().getOptions());
134176
} catch (Exception e) {
135177
return HotSpotCompilationRequestResult.failure(e.toString(), false);
@@ -140,7 +182,7 @@ public CompilationRequestResult compileMethod(CompilationRequest request) {
140182
public CompilationRequestResult compileMethod(CompilationRequest request, boolean installAsDefault, OptionValues initialOptions) {
141183
try (CompilationContext scope = HotSpotGraalServices.openLocalCompilationContext(request)) {
142184
if (graalRuntime.isShutdown()) {
143-
return HotSpotCompilationRequestResult.failure(String.format("Shutdown entered"), true);
185+
return HotSpotCompilationRequestResult.failure("Shutdown entered", true);
144186
}
145187

146188
ResolvedJavaMethod method = request.getMethod();

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotGraalCompilerFactory.java

-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,6 @@
4747
import jdk.vm.ci.meta.Signature;
4848
import jdk.vm.ci.runtime.JVMCICompilerFactory;
4949
import jdk.vm.ci.runtime.JVMCIRuntime;
50-
import jdk.vm.ci.services.Services;
5150
import org.graalvm.nativeimage.ImageInfo;
5251

5352
public final class HotSpotGraalCompilerFactory implements JVMCICompilerFactory {

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotGraalOptionValues.java

+54-18
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,8 @@
2727
import static jdk.vm.ci.common.InitTimer.timer;
2828

2929
import java.io.PrintStream;
30-
import java.util.HashMap;
30+
import java.util.Comparator;
31+
import java.util.List;
3132
import java.util.Map;
3233
import java.util.Set;
3334

@@ -42,6 +43,10 @@
4243

4344
import jdk.vm.ci.common.InitTimer;
4445
import jdk.vm.ci.common.NativeImageReinitialize;
46+
import org.graalvm.collections.EconomicSet;
47+
import org.graalvm.collections.MapCursor;
48+
import org.graalvm.nativeimage.ImageInfo;
49+
import org.graalvm.nativeimage.RuntimeOptions;
4550

4651
/**
4752
* The {@link #defaultOptions()} method returns the options values initialized in a HotSpot VM. The
@@ -112,8 +117,7 @@ public static EconomicMap<OptionKey<?>, Object> parseOptions() {
112117
Map<String, String> savedProps = GraalServices.getSavedProperties();
113118

114119
EconomicMap<String, String> compilerOptionSettings = EconomicMap.create();
115-
// Need to use Map as it's a shared type between guest and host in LibGraal.
116-
Map<String, String> vmOptionSettings = new HashMap<>();
120+
EconomicMap<String, String> vmOptionSettings = EconomicMap.create();
117121

118122
for (Map.Entry<String, String> e : savedProps.entrySet()) {
119123
String name = e.getKey();
@@ -168,14 +172,42 @@ private static String stripPrefix(String name, String prefix) {
168172
}
169173

170174
/**
171-
* Substituted by {@code Target_jdk_graal_compiler_hotspot_HotSpotGraalOptionValues}.
172-
*
173175
* @param settings unparsed libgraal option values
174176
*/
175-
private static void notifyLibgraalOptions(Map<String, String> settings) {
176-
System.err.printf("WARNING: Ignoring the following libgraal VM option(s) while executing jargraal: %s%n", String.join(", ", settings.keySet()));
177+
private static void notifyLibgraalOptions(EconomicMap<String, String> settings) {
178+
if (ImageInfo.inImageRuntimeCode()) {
179+
MapCursor<String, String> cursor = settings.getEntries();
180+
while (cursor.advance()) {
181+
String name = cursor.getKey();
182+
String stringValue = cursor.getValue();
183+
Object value;
184+
if (name.startsWith("X") && stringValue.isEmpty()) {
185+
name = name.substring(1);
186+
value = stringValue;
187+
} else {
188+
RuntimeOptions.Descriptor desc = RuntimeOptions.getDescriptor(name);
189+
if (desc == null) {
190+
throw new IllegalArgumentException("Could not find option " + name);
191+
}
192+
value = desc.convertValue(stringValue);
193+
explicitOptions.add(name);
194+
}
195+
try {
196+
RuntimeOptions.set(name, value);
197+
} catch (RuntimeException ex) {
198+
throw new IllegalArgumentException(ex);
199+
}
200+
}
201+
} else {
202+
System.err.printf("WARNING: Ignoring the following libgraal VM option(s) while executing jargraal: %s%n", settings.toString());
203+
}
177204
}
178205

206+
/**
207+
* The set of libgraal options seen on the command line.
208+
*/
209+
static EconomicSet<String> explicitOptions = EconomicSet.create();
210+
179211
private static OptionValues initializeOptions() {
180212
EconomicMap<OptionKey<?>, Object> values = parseOptions();
181213
OptionValues options = new OptionValues(values);
@@ -188,17 +220,21 @@ private static OptionValues initializeOptions() {
188220
static void printProperties(OptionValues compilerOptions, PrintStream out) {
189221
boolean all = HotSpotGraalCompilerFactory.Options.PrintPropertiesAll.getValue(compilerOptions);
190222
compilerOptions.printHelp(OptionsParser.getOptionsLoader(), out, GRAAL_OPTION_PROPERTY_PREFIX, all);
191-
if (all) {
192-
printLibgraalProperties(out, LIBGRAAL_VM_OPTION_PROPERTY_PREFIX);
223+
if (all && ImageInfo.inImageRuntimeCode()) {
224+
if (ImageInfo.inImageRuntimeCode()) {
225+
Comparator<RuntimeOptions.Descriptor> comparator = Comparator.comparing(RuntimeOptions.Descriptor::name);
226+
RuntimeOptions.listDescriptors().stream().sorted(comparator).forEach(d -> {
227+
String assign = explicitOptions.contains(d.name()) ? ":=" : "=";
228+
OptionValues.printHelp(out, LIBGRAAL_VM_OPTION_PROPERTY_PREFIX,
229+
d.name(),
230+
RuntimeOptions.get(d.name()),
231+
d.valueType(),
232+
assign,
233+
"[community edition]",
234+
d.help(),
235+
List.of());
236+
});
237+
}
193238
}
194239
}
195-
196-
/**
197-
* Substituted by {@code Target_jdk_graal_compiler_hotspot_HotSpotGraalOptionValues}.
198-
*
199-
* @param out where help is to be printed
200-
* @param prefix system property prefix for libgraal VM options
201-
*/
202-
private static void printLibgraalProperties(PrintStream out, String prefix) {
203-
}
204240
}

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/HotSpotGraalRuntime.java

+46-3
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,12 @@
3535
import java.util.Map;
3636
import java.util.function.Predicate;
3737

38+
import jdk.graal.compiler.word.Word;
39+
import jdk.graal.nativeimage.LibGraalRuntime;
40+
import jdk.vm.ci.hotspot.HotSpotVMConfigAccess;
41+
import org.graalvm.jniutils.JNI;
42+
import org.graalvm.jniutils.JNIExceptionWrapper;
43+
import org.graalvm.jniutils.JNIUtil;
3844
import org.graalvm.nativeimage.ImageInfo;
3945
import org.graalvm.collections.EconomicMap;
4046
import org.graalvm.collections.Equivalence;
@@ -67,7 +73,6 @@
6773
import jdk.graal.compiler.runtime.RuntimeProvider;
6874
import jdk.graal.compiler.serviceprovider.GraalServices;
6975
import jdk.graal.compiler.serviceprovider.JavaVersionUtil;
70-
import jdk.graal.compiler.serviceprovider.VMSupport;
7176
import jdk.vm.ci.code.Architecture;
7277
import jdk.vm.ci.code.stack.StackIntrospection;
7378
import jdk.vm.ci.common.InitTimer;
@@ -76,6 +81,7 @@
7681
import jdk.vm.ci.meta.JavaKind;
7782
import jdk.vm.ci.meta.MetaAccessProvider;
7883
import jdk.vm.ci.runtime.JVMCIBackend;
84+
import org.graalvm.nativeimage.StackValue;
7985
import org.graalvm.nativeimage.VMRuntime;
8086

8187
//JaCoCo Exclude
@@ -101,6 +107,15 @@ private static boolean checkArrayIndexScaleInvariants(MetaAccessProvider metaAcc
101107
private final String compilerConfigurationName;
102108
private final HotSpotBackend hostBackend;
103109

110+
/**
111+
* Since reference handling is synchronous in libgraal, explicitly perform it here and then run
112+
* any code which is expecting to process a reference queue to let it clean up.
113+
*/
114+
public static void doReferenceHandling() {
115+
LibGraalRuntime.processReferences();
116+
jdk.vm.ci.hotspot.Cleaner.clean();
117+
}
118+
104119
public GlobalMetrics getMetricValues() {
105120
return metricValues;
106121
}
@@ -433,10 +448,38 @@ synchronized void shutdown() {
433448
String cbClassName = callback.substring(0, lastDot);
434449
String cbMethodName = callback.substring(lastDot + 1);
435450

436-
VMSupport.invokeShutdownCallback(cbClassName, cbMethodName);
451+
JNI.JNIEnv env = Word.unsigned(getJNIEnv());
452+
JNI.JClass cbClass = JNIUtil.findClass(env, JNIUtil.getSystemClassLoader(env),
453+
JNIUtil.getBinaryName(cbClassName), true);
454+
JNI.JMethodID cbMethod = JNIUtil.findMethod(env, cbClass, true, cbMethodName, "()V");
455+
env.getFunctions().getCallStaticVoidMethodA().call(env, cbClass, cbMethod, StackValue.get(0));
456+
JNIExceptionWrapper.wrapAndThrowPendingJNIException(env);
457+
437458
}
438-
VMRuntime.initialize();
459+
VMRuntime.shutdown();
460+
}
461+
}
462+
463+
private static long jniEnvironmentOffset = Integer.MAX_VALUE;
464+
465+
private static long getJniEnvironmentOffset() {
466+
if (jniEnvironmentOffset == Integer.MAX_VALUE) {
467+
HotSpotJVMCIRuntime jvmciRuntime = HotSpotJVMCIRuntime.runtime();
468+
HotSpotVMConfigStore store = jvmciRuntime.getConfigStore();
469+
HotSpotVMConfigAccess config = new HotSpotVMConfigAccess(store);
470+
jniEnvironmentOffset = config.getFieldOffset("JavaThread::_jni_environment", Integer.class, "JNIEnv");
439471
}
472+
return jniEnvironmentOffset;
473+
}
474+
475+
/**
476+
* Gets the JNIEnv value for the current HotSpot thread.
477+
*/
478+
static long getJNIEnv() {
479+
HotSpotJVMCIRuntime jvmciRuntime = HotSpotJVMCIRuntime.runtime();
480+
long offset = getJniEnvironmentOffset();
481+
long javaThreadAddr = jvmciRuntime.getCurrentJavaThread();
482+
return javaThreadAddr + offset;
440483
}
441484

442485
void clearMetrics() {

‎compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/SymbolicSnippetEncoder.java

+1-2
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,6 @@
4242
import java.util.Set;
4343
import java.util.function.BiFunction;
4444

45-
import jdk.graal.compiler.serviceprovider.GraalServices;
4645
import org.graalvm.collections.EconomicMap;
4746
import org.graalvm.collections.EconomicSet;
4847
import org.graalvm.collections.MapCursor;
@@ -143,7 +142,7 @@
143142
* method references into a symbolic form that can be resolved at graph decode time using
144143
* {@link SymbolicJVMCIReference}.
145144
* <p>
146-
* An instance of this class only exist when {@link GraalServices#isBuildingLibgraal()} is true.
145+
* An instance of this class only exist when building libgraal.
147146
*/
148147
public class SymbolicSnippetEncoder {
149148

0 commit comments

Comments
 (0)