[prev in list] [next in list] [prev in thread] [next in thread] 

List:       openjdk-hotspot-runtime-dev
Subject:    Integrated: JDK-8317661: [REDO] store/load order not preserved when handling memory pool due to weak
From:       Damon Fenacci <dfenacci () openjdk ! org>
Date:       2023-10-27 12:58:40
Message-ID: 9Rv9FFbhlQenO4WBXr4WDhr4fSqUw-wDObfIetqKgBI=.902dcc0d-6f5c-4429-9ae0-cfd373cef4b9 () github ! com
[Download RAW message or body]

On Wed, 11 Oct 2023 09:56:37 GMT, Damon Fenacci <dfenacci@openjdk.org> wrote:

> # Issue
> An intermittent _Memory Pool not found_ error has been noticed when running  a few \
> tests (_vmTestbase/vm/mlvm/meth/stress/compiler/deoptimize/Test.java_, \
> _vmTestbase/vm/mlvm/meth/stress/compiler/sequences/Test.java_) on _macosx_aarch64_ \
> (production build) with non-segmented code cache. 
> ## Origin
> The issue originates from the fact that aarch64 architecture is a weakly ordered \
> memory architecture, i.e. it _permits the observation and completion of memory \
> accesses in a different order from the program order_. 
> More precisely: while calling `CodeHeapPool::get_memory_usage`, the `used` and \
> `committed` variables are retrieved \
> https://github.com/openjdk/jdk/blob/138542de7889e8002df0e15a79e31d824c6a0473/src/hotspot/share/services/memoryPool.cpp#L181-L182
>  and these are computed based on different variables saved in memory in \
> `CodeCache::allocate` (during `heap->allocate` and `heap->expand_by` to be precise) \
> .https://github.com/openjdk/jdk/blob/138542de7889e8002df0e15a79e31d824c6a0473/src/hotspot/share/code/codeCache.cpp#L535-L537
>  The problem happens when first `heap->expand_by` gets called (which _increases_ \
> `committed`) and then `heap->allocate` gets called in a second loop pass (which \
> _increases_ `used`). Although stores in `CodeCache::allocate` happen in the this \
> order, when reading from memory in `CodeHeapPool::get_memory_usage` it can happen \
> that `used` has the newly computed value, while `committed` is still "old" (because \
> of ARM's weak memory order). This is a problem, since `committed` must be > than \
> `used`. 
> # Solution
> 
> To avoid this situation we must assure that values used to calculate `committed` \
> are actually saved before the values used to calculate `used` and that the opposite \
> be true for reading. To enforce this explicit barriers are introduced: \
> `OrderAccess::release` in `CodeCache::allocate` if we need to expand the heap, to \
> ensure heap expansion is visible before we allocate, and `OrderAccess::acquire` \
> before calculating `committed` in `CodeHeapPool::get_memory_usage` to make sure \
> that the cache expansion is seen. 
> Acquiring a `CodeCache_lock` has been attempted in #15819 but resulted in deadlocks \
> (that seem to be unavoidable).

This pull request has now been integrated.

Changeset: ddd07161
Author:    Damon Fenacci <dfenacci@openjdk.org>
URL:       https://git.openjdk.org/jdk/commit/ddd071617e7bc25c496973b231d02ced438d1344
                
Stats:     3 lines in 2 files changed: 3 ins; 0 del; 0 mod

8317661: [REDO] store/load order not preserved when handling memory pool due to \
weakly ordered memory architecture of aarch64

Reviewed-by: dholmes, aph

-------------

PR: https://git.openjdk.org/jdk/pull/16143


[prev in list] [next in list] [prev in thread] [next in thread]