MemoryBarriers (Graal OpenJDK Project Documentation)

java.lang.Object
- jdk.internal.jvmci.code.MemoryBarriers

public class MemoryBarriers
extends Object

Constants and intrinsic definition for memory barriers. The documentation for each constant is taken from Doug Lea's The JSR-133 Cookbook for Compiler Writers.

The JMM_* constants capture the memory barriers necessary to implement the Java Memory Model with respect to volatile field accesses. Their values are explained by this comment from templateTable_i486.cpp in the HotSpot source code:

 Volatile variables demand their effects be made known to all CPU's in
 order.  Store buffers on most chips allow reads & writes to reorder; the
 JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of
 memory barrier (i.e., it's not sufficient that the interpreter does not
 reorder volatile references, the hardware also must not reorder them).

 According to the new Java Memory Model (JMM):
 (1) All volatiles are serialized wrt to each other.
 ALSO reads & writes act as acquire & release, so:
 (2) A read cannot let unrelated NON-volatile memory refs that happen after
 the read float up to before the read.  It's OK for non-volatile memory refs
 that happen before the volatile read to float down below it.
 (3) Similarly, a volatile write cannot let unrelated NON-volatile memory refs
 that happen BEFORE the write float down to after the write.  It's OK for
 non-volatile memory refs that happen after the volatile write to float up
 before it.

 We only put in barriers around volatile refs (they are expensive), not
 _between_ memory refs (which would require us to track the flavor of the
 previous memory refs).  Requirements (2) and (3) require some barriers
 before volatile stores and after volatile loads.  These nearly cover
 requirement (1) but miss the volatile-store-volatile-load case.  This final
 case is placed after volatile-stores although it could just as well go
 before volatile-loads.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`JMM_POST_VOLATILE_READ`
`static int`	`JMM_POST_VOLATILE_WRITE`
`static int`	`JMM_PRE_VOLATILE_READ`
`static int`	`JMM_PRE_VOLATILE_WRITE`
`static int`	`LOAD_LOAD` The sequence `Load1; LoadLoad; Load2` ensures that `Load1`'s data are loaded before data accessed by `Load2` and all subsequent load instructions are loaded.
`static int`	`LOAD_STORE` The sequence `Load1; LoadStore; Store2` ensures that `Load1`'s data are loaded before all data associated with `Store2` and subsequent store instructions are flushed.
`static int`	`STORE_LOAD` The sequence `Store1; StoreLoad; Load2` ensures that `Store1`'s data are made visible to other processors (i.e., flushed to main memory) before data accessed by `Load2` and all subsequent load instructions are loaded.
`static int`	`STORE_STORE` The sequence `Store1; StoreStore; Store2` ensures that `Store1`'s data are visible to other processors (i.e., flushed to memory) before the data associated with `Store2` and all subsequent store instructions.

Constructor Summary

Constructors
Constructor and Description

MemoryBarriers()

Constructors
Constructor and Description
`MemoryBarriers()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type Method and Description

static String barriersString(int barriers)
- Methods inherited from class java.lang.Object
  clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static String`	`barriersString(int barriers)`

- Field Detail
  - LOAD_LOAD
```
public static final int LOAD_LOAD
```
    The sequence Load1; LoadLoad; Load2 ensures that Load1's data are loaded before data accessed by Load2 and all subsequent load instructions are loaded. In general, explicit LoadLoad barriers are needed on processors that perform speculative loads and/or out-of-order processing in which waiting load instructions can bypass waiting stores. On processors that guarantee to always preserve load ordering, these barriers amount to no-ops.
    
    See Also:
    
    Constant Field Values
  - LOAD_STORE
```
public static final int LOAD_STORE
```
    The sequence Load1; LoadStore; Store2 ensures that Load1's data are loaded before all data associated with Store2 and subsequent store instructions are flushed. LoadStore barriers are needed only on those out-of-order processors in which waiting store instructions can bypass loads.
    
    See Also:
    
    Constant Field Values
  - STORE_LOAD
```
public static final int STORE_LOAD
```
    The sequence Store1; StoreLoad; Load2 ensures that Store1's data are made visible to other processors (i.e., flushed to main memory) before data accessed by Load2 and all subsequent load instructions are loaded. StoreLoad barriers protect against a subsequent load incorrectly using Store1's data value rather than that from a more recent store to the same location performed by a different processor. Because of this, on the processors discussed below, a StoreLoad is strictly necessary only for separating stores from subsequent loads of the same location(s) as were stored before the barrier. StoreLoad barriers are needed on nearly all recent multiprocessors, and are usually the most expensive kind. Part of the reason they are expensive is that they must disable mechanisms that ordinarily bypass cache to satisfy loads from write-buffers. This might be implemented by letting the buffer fully flush, among other possible stalls.
    
    See Also:
    
    Constant Field Values
  - STORE_STORE
```
public static final int STORE_STORE
```
    The sequence Store1; StoreStore; Store2 ensures that Store1's data are visible to other processors (i.e., flushed to memory) before the data associated with Store2 and all subsequent store instructions. In general, StoreStore barriers are needed on processors that do not otherwise guarantee strict ordering of flushes from write buffers and/or caches to other processors or main memory.
    
    See Also:
    
    Constant Field Values
  - JMM_PRE_VOLATILE_WRITE
```
public static final int JMM_PRE_VOLATILE_WRITE
```
    See Also:
    
    Constant Field Values
  - JMM_POST_VOLATILE_WRITE
```
public static final int JMM_POST_VOLATILE_WRITE
```
    See Also:
    
    Constant Field Values
  - JMM_PRE_VOLATILE_READ
```
public static final int JMM_PRE_VOLATILE_READ
```
    See Also:
    
    Constant Field Values
  - JMM_POST_VOLATILE_READ
```
public static final int JMM_POST_VOLATILE_READ
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MemoryBarriers
```
public MemoryBarriers()
```
- Method Detail
  - barriersString
```
public static String barriersString(int barriers)
```

Class MemoryBarriers

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOAD_LOAD

LOAD_STORE

STORE_LOAD

STORE_STORE

JMM_PRE_VOLATILE_WRITE

JMM_POST_VOLATILE_WRITE

JMM_PRE_VOLATILE_READ

JMM_POST_VOLATILE_READ

Constructor Detail

MemoryBarriers

Method Detail

barriersString