src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/SpeculationLog.java
Index
Unified diffs
Context diffs
Sdiffs
Frames
Patch
New
Old
Previous File
Next File
open Cdiff src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/SpeculationLog.java
src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/SpeculationLog.java
Print this page
*** 1,7 ****
/*
! * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
--- 1,7 ----
/*
! * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*** 20,52 ****
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.vm.ci.meta;
/**
! * Manages unique deoptimization reasons. Reasons are embedded in compiled code and can be
! * invalidated at run time. Subsequent compilations then should not speculate again on such
! * invalidated reasons to avoid repeated deoptimization.
! *
! * All methods of this interface are called by the compiler. There is no need for API to register
! * failed speculations during deoptimization, since every VM has different needs there.
*/
public interface SpeculationLog {
/**
! * Marker interface for speculation objects that can be added to the speculation log.
*/
public interface SpeculationReason {
}
/**
* Marker class that indicates that a speculation has no reason.
*/
final class NoSpeculationReason implements SpeculationReason {
}
class Speculation {
! private SpeculationReason reason;
public Speculation(SpeculationReason reason) {
this.reason = reason;
}
--- 20,105 ----
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.vm.ci.meta;
+ import java.util.Map;
+ import java.util.function.Supplier;
+
/**
! * Manages unique {@link SpeculationReason} objects that denote why a deoptimization occurred.
! * Reasons are embedded in compiled code for a method. If the compiled code deoptimizes at a
! * position associated with a {@link SpeculationReason}, the reason is added to a set of failed
! * speculations associated with the method. A subsequent compilation of the method can query the
! * failed speculations via a {@link SpeculationLog} to avoid making a speculation based on
! * invalidated reasons. This avoids repeated deoptimizations.
*/
public interface SpeculationLog {
/**
! * The specific attributes of a speculation that a compiler uses to denote a speculation in a
! * compiled method. Typical attributes of a speculation are a bytecode position, type
! * information about a variable being speculated on and an enum denoting the type of operation
! * to which the speculation applies. A {@link SpeculationReason} is used as a key in a
! * {@link Map} and so it must implement {@link Object#equals(Object)} and
! * {@link Object#hashCode()} in terms of its attributes.
! *
! * A JVMCI implementation may serialize speculations for storage off heap (e.g. in native memory
! * associated with an nmethod). For this reason, the attributes of a {@link SpeculationReason}
! * are restricted to those supported by the {@code add...} methods of
! * {@link SpeculationReasonEncoding}.
*/
public interface SpeculationReason {
+
+ /**
+ * Encodes the attributes of this reason using a {@link SpeculationReasonEncoding}. For
+ * efficiency, a {@link SpeculationReason} implementation should cache the returned value
+ * and return it for all subsequent calls to this method. This also underlines the
+ * requirement that the encoding for a specific reason instance should be stable.
+ *
+ * @param encodingSupplier source of a {@link SpeculationReasonEncoding}
+ * @return a {@link SpeculationReasonEncoding} that encodes all the attributes that uniquely
+ * identify this reason
+ */
+ default SpeculationReasonEncoding encode(Supplier<SpeculationReasonEncoding> encodingSupplier) {
+ return null;
+ }
+ }
+
+ /**
+ * Provides a facility for encoding the attributes of a {@link SpeculationReason}. The encoding
+ * format is determined by the implementation of this interface.
+ */
+ public interface SpeculationReasonEncoding {
+ void addByte(int value);
+
+ void addShort(int value);
+
+ void addInt(int value);
+
+ void addLong(long value);
+
+ void addMethod(ResolvedJavaMethod method);
+
+ void addType(ResolvedJavaType type);
+
+ void addString(String value);
+
+ default void addField(ResolvedJavaField field) {
+ addType(field.getDeclaringClass());
+ addInt(field.getModifiers());
+ addInt(field.getOffset());
+ }
}
/**
* Marker class that indicates that a speculation has no reason.
*/
final class NoSpeculationReason implements SpeculationReason {
}
class Speculation {
! private final SpeculationReason reason;
public Speculation(SpeculationReason reason) {
this.reason = reason;
}
*** 75,85 ****
}
Speculation NO_SPECULATION = new Speculation(new NoSpeculationReason());
/**
! * Must be called before compilation, i.e., before a compiler calls {@link #maySpeculate}.
*/
void collectFailedSpeculations();
/**
* If this method returns true, the compiler is allowed to {@link #speculate} with the given
--- 128,139 ----
}
Speculation NO_SPECULATION = new Speculation(new NoSpeculationReason());
/**
! * Updates the set of failed speculations recorded in this log. This must be called before
! * compilation.
*/
void collectFailedSpeculations();
/**
* If this method returns true, the compiler is allowed to {@link #speculate} with the given
src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.meta/src/jdk/vm/ci/meta/SpeculationLog.java
Index
Unified diffs
Context diffs
Sdiffs
Frames
Patch
New
Old
Previous File
Next File