|
28 | 28 | #include "oops/oop.inline.hpp" |
29 | 29 | #include "runtime/javaThread.inline.hpp" |
30 | 30 | #include "runtime/mutexLocker.hpp" |
31 | | -#include "runtime/vm_version.hpp" |
32 | 31 | #include "utilities/copy.hpp" |
33 | 32 | #include "utilities/debug.hpp" |
34 | 33 | #include "utilities/vmError.hpp" |
35 | 34 |
|
36 | 35 | namespace AccessInternal { |
37 | | - // VM_Version::supports_cx8() is a surrogate for 'supports atomic long memory ops'. |
38 | | - // |
39 | | - // On platforms which do not support atomic compare-and-swap of jlong (8 byte) |
40 | | - // values we have to use a lock-based scheme to enforce atomicity. This has to be |
41 | | - // applied to all Unsafe operations that set the value of a jlong field. Even so |
42 | | - // the compareAndSwapLong operation will not be atomic with respect to direct stores |
43 | | - // to the field from Java code. It is important therefore that any Java code that |
44 | | - // utilizes these Unsafe jlong operations does not perform direct stores. To permit |
45 | | - // direct loads of the field from Java code we must also use Atomic::store within the |
46 | | - // locked regions. And for good measure, in case there are direct stores, we also |
47 | | - // employ Atomic::load within those regions. Note that the field in question must be |
48 | | - // volatile and so must have atomic load/store accesses applied at the Java level. |
49 | | - // |
50 | | - // The locking scheme could utilize a range of strategies for controlling the locking |
51 | | - // granularity: from a lock per-field through to a single global lock. The latter is |
52 | | - // the simplest and is used for the current implementation. Note that the Java object |
53 | | - // that contains the field, can not, in general, be used for locking. To do so can lead |
54 | | - // to deadlocks as we may introduce locking into what appears to the Java code to be a |
55 | | - // lock-free path. |
56 | | - // |
57 | | - // As all the locked-regions are very short and themselves non-blocking we can treat |
58 | | - // them as leaf routines and elide safepoint checks (ie we don't perform any thread |
59 | | - // state transitions even when blocking for the lock). Note that if we do choose to |
60 | | - // add safepoint checks and thread state transitions, we must ensure that we calculate |
61 | | - // the address of the field _after_ we have acquired the lock, else the object may have |
62 | | - // been moved by the GC |
63 | | - |
64 | | -#ifndef SUPPORTS_NATIVE_CX8 |
65 | | - |
66 | | - // This is intentionally in the cpp file rather than the .inline.hpp file. It seems |
67 | | - // desirable to trade faster JDK build times (not propagating vm_version.hpp) |
68 | | - // for slightly worse runtime atomic jlong performance on 32 bit machines with |
69 | | - // support for 64 bit atomics. |
70 | | - bool wide_atomic_needs_locking() { |
71 | | - return !VM_Version::supports_cx8(); |
72 | | - } |
73 | | - |
74 | | - AccessLocker::AccessLocker() { |
75 | | - assert(!VM_Version::supports_cx8(), "why else?"); |
76 | | - UnsafeJlong_lock->lock_without_safepoint_check(); |
77 | | - } |
78 | | - |
79 | | - AccessLocker::~AccessLocker() { |
80 | | - UnsafeJlong_lock->unlock(); |
81 | | - } |
82 | | - |
83 | | -#endif |
84 | | - |
85 | 36 | // These forward copying calls to Copy without exposing the Copy type in headers unnecessarily |
86 | 37 |
|
87 | 38 | void arraycopy_arrayof_conjoint_oops(void* src, void* dst, size_t length) { |
|
0 commit comments