GraalDirectives (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.api.directives.GraalDirectives

```
public final class GraalDirectives
extends Object
```
Directives that influence the compilation of methods by Graal. They don't influence the semantics of the code, but they are useful for unit testing and benchmarking.

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`FASTPATH_PROBABILITY`
`static double`	`LIKELY_PROBABILITY`
`static double`	`SLOWPATH_PROBABILITY`
`static double`	`UNLIKELY_PROBABILITY`

Constructor Summary

Constructors
Constructor and Description

GraalDirectives()

Constructors
Constructor and Description
`GraalDirectives()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`blackhole(boolean value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(byte value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(char value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(double value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(float value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(int value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(long value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(Object value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`blackhole(short value)` Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
`static void`	`controlFlowAnchor()` A call to this method will never be duplicated by control flow optimizations in the compiler.
`static void`	`deoptimize()` Directive for the compiler to fall back to the bytecode interpreter at this point.
`static void`	`deoptimizeAndInvalidate()` Directive for the compiler to fall back to the bytecode interpreter at this point, invalidate the compiled code and reprofile the method.
`static void`	`ensureVirtualized(Object object)` Ensures that the given object will be virtual (escape analyzed) at all points that are dominated by the current position.
`static void`	`ensureVirtualizedHere(Object object)` Ensures that the given object will be virtual at the current position.
`static <T> T`	`guardingNonNull(T value)`
`static boolean`	`inCompiledCode()` Returns a boolean value indicating whether the method is executed in Graal-compiled code.
`static boolean`	`injectBranchProbability(double probability, boolean condition)` Injects a probability for the given condition into the profiling information of a branch instruction.
`static boolean`	`injectIterationCount(double iterations, boolean condition)` Injects an average iteration count of a loop into the probability information of a loop exit condition.
`static boolean`	`opaque(boolean value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static byte`	`opaque(byte value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static char`	`opaque(char value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static double`	`opaque(double value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static float`	`opaque(float value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static int`	`opaque(int value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static long`	`opaque(long value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static short`	`opaque(short value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.
`static <T> T`	`opaque(T value)` Do nothing, but also make sure the compiler doesn't do any optimizations across this call.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LIKELY_PROBABILITY
```
public static final double LIKELY_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - UNLIKELY_PROBABILITY
```
public static final double UNLIKELY_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - SLOWPATH_PROBABILITY
```
public static final double SLOWPATH_PROBABILITY
```
    See Also:
    
    Constant Field Values
  - FASTPATH_PROBABILITY
```
public static final double FASTPATH_PROBABILITY
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - GraalDirectives
```
public GraalDirectives()
```
- Method Detail
  - deoptimize
```
public static void deoptimize()
```
    Directive for the compiler to fall back to the bytecode interpreter at this point.
  - deoptimizeAndInvalidate
```
public static void deoptimizeAndInvalidate()
```
    Directive for the compiler to fall back to the bytecode interpreter at this point, invalidate the compiled code and reprofile the method.
  - inCompiledCode
```
public static boolean inCompiledCode()
```
    Returns a boolean value indicating whether the method is executed in Graal-compiled code.
  - controlFlowAnchor
```
public static void controlFlowAnchor()
```
    A call to this method will never be duplicated by control flow optimizations in the compiler.
  - injectBranchProbability
```
public static boolean injectBranchProbability(double probability,
                                              boolean condition)
```
    Injects a probability for the given condition into the profiling information of a branch instruction. The probability must be a value between 0.0 and 1.0 (inclusive). Example usage (it specifies that the likelihood for a to be greater than b is 90%): if (injectBranchProbability(0.9, a > b)) { // ... } There are predefined constants for commonly used probabilities (see LIKELY_PROBABILITY , UNLIKELY_PROBABILITY, SLOWPATH_PROBABILITY, FASTPATH_PROBABILITY ).
    
    Parameters:
    
    probability - the probability value between 0.0 and 1.0 that should be injected
  - injectIterationCount
```
public static boolean injectIterationCount(double iterations,
                                           boolean condition)
```
    Injects an average iteration count of a loop into the probability information of a loop exit condition. The iteration count specifies how often the condition is checked, i.e. in for and while loops it is one more than the body iteration count, and in do-while loops it is equal to the body iteration count. The iteration count must be >= 1.0. Example usage (it specifies that the expected iteration count of the loop condition is 500, so the iteration count of the loop body is 499): for (int i = 0; injectIterationCount(500, i < array.length); i++) { // ... }
    
    Parameters:
    
    iterations - the expected number of iterations that should be injected
  - blackhole
```
public static void blackhole(boolean value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(byte value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(short value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(char value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(int value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(long value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(float value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(double value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - blackhole
```
public static void blackhole(Object value)
```
    Consume a value, making sure the compiler doesn't optimize away the computation of this value, even if it is otherwise unused.
  - opaque
```
public static boolean opaque(boolean value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static byte opaque(byte value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static short opaque(short value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static char opaque(char value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static int opaque(int value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static long opaque(long value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static float opaque(float value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static double opaque(double value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - opaque
```
public static <T> T opaque(T value)
```
    Do nothing, but also make sure the compiler doesn't do any optimizations across this call. For example, the compiler will constant fold the expression 5 * 3, but the expression 5 * opaque(3) will result in a real multiplication, because the compiler will not see that opaque(3) is a constant.
  - guardingNonNull
```
public static <T> T guardingNonNull(T value)
```
  - ensureVirtualized
```
public static void ensureVirtualized(Object object)
```
    Ensures that the given object will be virtual (escape analyzed) at all points that are dominated by the current position.
  - ensureVirtualizedHere
```
public static void ensureVirtualizedHere(Object object)
```
    Ensures that the given object will be virtual at the current position.

Class GraalDirectives

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LIKELY_PROBABILITY

UNLIKELY_PROBABILITY

SLOWPATH_PROBABILITY

FASTPATH_PROBABILITY

Constructor Detail

GraalDirectives

Method Detail

deoptimize

deoptimizeAndInvalidate

inCompiledCode

controlFlowAnchor

injectBranchProbability

injectIterationCount

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

blackhole

opaque

opaque

opaque

opaque

opaque

opaque

opaque

opaque

opaque

guardingNonNull

ensureVirtualized

ensureVirtualizedHere