This class defines low-level methods to access on-heap and off-heap memory. The methods in this class can be thought of as thin wrappers around methods provided in the Unsafe class. All the methods in this class accept one or more MemorySessionImpl parameter, which is used to validate as to whether access to memory can be performed in a safe fashion - more specifically, to ensure that the memory being accessed has not already been released (which would result in a hard VM crash).

Accessing and releasing memory from a single thread is not problematic - after all, a given thread cannot, at the same time, access a memory region and free it. But ensuring correctness of memory access when multiple threads are involved is much trickier, as there can be cases where a thread is accessing a memory region while another thread is releasing it.

This class provides tools to manage races when multiple threads are accessing and/or releasing the same memory session concurrently. More specifically, when a thread wants to release a memory session, it should call the ScopedMemoryAccess#closeScope(MemorySessionImpl) method. This method initiates thread-local handshakes with all the other VM threads, which are then stopped one by one. If any thread is found accessing a resource associated to the very memory session being closed, the handshake fails, and the session will not be closed.

This synchronization strategy relies on the idea that accessing memory is atomic with respect to checking the validity of the session associated with that memory region - that is, a thread that wants to perform memory access will be suspended either before a liveness check or after the memory access. To ensure this atomicity, all methods in this class are marked with the special Scoped annotation, which is recognized by the VM, and used during the thread-local handshake to detect (and stop) threads performing potentially problematic memory access operations. Additionally, to make sure that the session object(s) of the memory being accessed is always reachable during an access operation, all the methods in this class add reachability fences around the underlying unsafe access.

This form of synchronization allows APIs to use plain memory access without any other form of synchronization which might be deemed to expensive; in other words, this approach prioritizes the performance of memory access over that of releasing a shared memory resource.