18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHLOCK_HPP
26 #define SHARE_GC_SHENANDOAH_SHENANDOAHLOCK_HPP
27
28 #include "gc/shenandoah/shenandoahPadding.hpp"
29 #include "memory/allocation.hpp"
30 #include "runtime/javaThread.hpp"
31 #include "runtime/safepoint.hpp"
32
33 class ShenandoahLock {
34 private:
35 enum LockState { unlocked = 0, locked = 1 };
36
37 shenandoah_padding(0);
38 volatile int _state;
39 shenandoah_padding(1);
40 volatile Thread* _owner;
41 shenandoah_padding(2);
42
43 public:
44 ShenandoahLock() : _state(unlocked), _owner(nullptr) {};
45
46 void lock() {
47 #ifdef ASSERT
48 assert(_owner != Thread::current(), "reentrant locking attempt, would deadlock");
49 #endif
50 Thread::SpinAcquire(&_state, "Shenandoah Heap Lock");
51 #ifdef ASSERT
52 assert(_state == locked, "must be locked");
53 assert(_owner == nullptr, "must not be owned");
54 _owner = Thread::current();
55 #endif
56 }
57
58 void unlock() {
59 #ifdef ASSERT
60 assert (_owner == Thread::current(), "sanity");
61 _owner = nullptr;
62 #endif
63 Thread::SpinRelease(&_state);
64 }
65
66 bool owned_by_self() {
67 #ifdef ASSERT
68 return _state == locked && _owner == Thread::current();
69 #else
70 ShouldNotReachHere();
71 return false;
72 #endif
73 }
74 };
75
76 class ShenandoahLocker : public StackObj {
77 private:
78 ShenandoahLock* const _lock;
79 public:
80 ShenandoahLocker(ShenandoahLock* lock) : _lock(lock) {
81 if (_lock != nullptr) {
82 _lock->lock();
83 }
84 }
85
86 ~ShenandoahLocker() {
87 if (_lock != nullptr) {
88 _lock->unlock();
89 }
90 }
91 };
92
93 class ShenandoahSimpleLock {
94 private:
95 PlatformMonitor _lock; // native lock
96 public:
97 ShenandoahSimpleLock();
98
99 virtual void lock();
100 virtual void unlock();
101 };
102
|
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHLOCK_HPP
26 #define SHARE_GC_SHENANDOAH_SHENANDOAHLOCK_HPP
27
28 #include "gc/shenandoah/shenandoahPadding.hpp"
29 #include "memory/allocation.hpp"
30 #include "runtime/javaThread.hpp"
31 #include "runtime/safepoint.hpp"
32
33 class ShenandoahLock {
34 private:
35 enum LockState { unlocked = 0, locked = 1 };
36
37 shenandoah_padding(0);
38 volatile LockState _state;
39 shenandoah_padding(1);
40 volatile Thread* _owner;
41 shenandoah_padding(2);
42
43 template<typename BlockOp>
44 void contended_lock_internal(JavaThread* java_thread);
45
46 public:
47 ShenandoahLock() : _state(unlocked), _owner(nullptr) {};
48
49 void lock(bool allow_block_for_safepoint) {
50 assert(Atomic::load(&_owner) != Thread::current(), "reentrant locking attempt, would deadlock");
51
52 // Try to lock fast, or dive into contended lock handling.
53 if (Atomic::cmpxchg(&_state, unlocked, locked) != unlocked) {
54 contended_lock(allow_block_for_safepoint);
55 }
56
57 assert(Atomic::load(&_state) == locked, "must be locked");
58 assert(Atomic::load(&_owner) == nullptr, "must not be owned");
59 DEBUG_ONLY(Atomic::store(&_owner, Thread::current());)
60 }
61
62 void unlock() {
63 assert(Atomic::load(&_owner) == Thread::current(), "sanity");
64 DEBUG_ONLY(Atomic::store(&_owner, (Thread*)nullptr);)
65 OrderAccess::fence();
66 Atomic::store(&_state, unlocked);
67 }
68
69 void contended_lock(bool allow_block_for_safepoint);
70
71 bool owned_by_self() {
72 #ifdef ASSERT
73 return _state == locked && _owner == Thread::current();
74 #else
75 ShouldNotReachHere();
76 return false;
77 #endif
78 }
79 };
80
81 class ShenandoahLocker : public StackObj {
82 private:
83 ShenandoahLock* const _lock;
84 public:
85 ShenandoahLocker(ShenandoahLock* lock, bool allow_block_for_safepoint = false) : _lock(lock) {
86 if (_lock != nullptr) {
87 _lock->lock(allow_block_for_safepoint);
88 }
89 }
90
91 ~ShenandoahLocker() {
92 if (_lock != nullptr) {
93 _lock->unlock();
94 }
95 }
96 };
97
98 class ShenandoahSimpleLock {
99 private:
100 PlatformMonitor _lock; // native lock
101 public:
102 ShenandoahSimpleLock();
103
104 virtual void lock();
105 virtual void unlock();
106 };
107
|