11/*
22 * Copyright (c) 2022, Red Hat, Inc. All rights reserved.
33 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
4+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
45 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
56 *
67 * This code is free software; you can redistribute it and/or modify it
2627#ifndef SHARE_RUNTIME_LOCKSTACK_INLINE_HPP
2728#define SHARE_RUNTIME_LOCKSTACK_INLINE_HPP
2829
30+ #include " runtime/lockStack.hpp"
31+
2932#include " memory/iterator.hpp"
3033#include " runtime/javaThread.hpp"
31- #include " runtime/lockStack.hpp"
3234#include " runtime/safepoint.hpp"
3335#include " runtime/stackWatermark.hpp"
3436#include " runtime/stackWatermarkSet.inline.hpp"
37+ #include " utilities/align.hpp"
38+ #include " utilities/globalDefinitions.hpp"
3539
3640inline int LockStack::to_index (uint32_t offset) {
41+ assert (is_aligned (offset, oopSize), " Bad alignment: %u"
42+ assert ((offset <= end_offset ()), " lockstack overflow: offset %d end_offset %d" end_offset ());
43+ assert ((offset >= start_offset ()), " lockstack underflow: offset %d start_offset %d" start_offset ());
3744 return (offset - lock_stack_base_offset) / oopSize;
3845}
3946
@@ -42,8 +49,8 @@ JavaThread* LockStack::get_thread() const {
4249 return reinterpret_cast <JavaThread*>(addr - lock_stack_offset);
4350}
4451
45- inline bool LockStack::can_push () const {
46- return to_index (_top) < CAPACITY;
52+ inline bool LockStack::is_full () const {
53+ return to_index (_top) == CAPACITY;
4754}
4855
4956inline bool LockStack::is_owning_thread () const {
@@ -61,32 +68,132 @@ inline void LockStack::push(oop o) {
6168 verify (" pre-push"
6269 assert (oopDesc::is_oop (o), " must be"
6370 assert (!contains (o), " entries must be unique"
64- assert (can_push (), " must have room"
71+ assert (! is_full (), " must have room"
6572 assert (_base[to_index (_top)] == nullptr , " expect zapped entry"
6673 _base[to_index (_top)] = o;
6774 _top += oopSize;
6875 verify (" post-push"
6976}
7077
71- inline void LockStack::remove (oop o) {
78+ inline oop LockStack::bottom () const {
79+ assert (to_index (_top) > 0 , " must contain an oop"
80+ return _base[0 ];
81+ }
82+
83+ inline bool LockStack::is_empty () const {
84+ return to_index (_top) == 0 ;
85+ }
86+
87+ inline bool LockStack::is_recursive (oop o) const {
88+ if (!VM_Version::supports_recursive_lightweight_locking ()) {
89+ return false ;
90+ }
91+ verify (" pre-is_recursive"
92+
93+ // This will succeed iff there is a consecutive run of oops on the
94+ // lock-stack with a length of at least 2.
95+
96+ assert (contains (o), " at least one entry must exist"
97+ int end = to_index (_top);
98+ // Start iterating from the top because the runtime code is more
99+ // interested in the balanced locking case when the top oop on the
100+ // lock-stack matches o. This will cause the for loop to break out
101+ // in the first loop iteration if it is non-recursive.
102+ for (int i = end - 1 ; i > 0 ; i--) {
103+ if (_base[i - 1 ] == o && _base[i] == o) {
104+ verify (" post-is_recursive"
105+ return true ;
106+ }
107+ if (_base[i] == o) {
108+ // o can only occur in one consecutive run on the lock-stack.
109+ // Only one of the two oops checked matched o, so this run
110+ // must be of length 1 and thus not be recursive. Stop the search.
111+ break ;
112+ }
113+ }
114+
115+ verify (" post-is_recursive"
116+ return false ;
117+ }
118+
119+ inline bool LockStack::try_recursive_enter (oop o) {
120+ if (!VM_Version::supports_recursive_lightweight_locking ()) {
121+ return false ;
122+ }
123+ verify (" pre-try_recursive_enter"
124+
125+ // This will succeed iff the top oop on the stack matches o.
126+ // When successful o will be pushed to the lock-stack creating
127+ // a consecutive run at least 2 oops that matches o on top of
128+ // the lock-stack.
129+
130+ assert (!is_full (), " precond"
131+
132+ int end = to_index (_top);
133+ if (end == 0 || _base[end - 1 ] != o) {
134+ // Topmost oop does not match o.
135+ verify (" post-try_recursive_enter"
136+ return false ;
137+ }
138+
139+ _base[end] = o;
140+ _top += oopSize;
141+ verify (" post-try_recursive_enter"
142+ return true ;
143+ }
144+
145+ inline bool LockStack::try_recursive_exit (oop o) {
146+ if (!VM_Version::supports_recursive_lightweight_locking ()) {
147+ return false ;
148+ }
149+ verify (" pre-try_recursive_exit"
150+
151+ // This will succeed iff the top two oops on the stack matches o.
152+ // When successful the top oop will be popped of the lock-stack.
153+ // When unsuccessful the lock may still be recursive, in which
154+ // case the locking is unbalanced. This case is handled externally.
155+
156+ assert (contains (o), " entries must exist"
157+
158+ int end = to_index (_top);
159+ if (end <= 1 || _base[end - 1 ] != o || _base[end - 2 ] != o) {
160+ // The two topmost oops do not match o.
161+ verify (" post-try_recursive_exit"
162+ return false ;
163+ }
164+
165+ _top -= oopSize;
166+ DEBUG_ONLY (_base[to_index (_top)] = nullptr ;)
167+ verify (" post-try_recursive_exit"
168+ return true ;
169+ }
170+
171+ inline size_t LockStack::remove (oop o) {
72172 verify (" pre-remove"
73173 assert (contains (o), " entry must be present: " p2i (o));
174+
74175 int end = to_index (_top);
176+ int inserted = 0 ;
75177 for (int i = 0 ; i < end; i++) {
76- if (_base[i] == o) {
77- int last = end - 1 ;
78- for (; i < last; i++) {
79- _base[i] = _base[i + 1 ];
178+ if (_base[i] != o) {
179+ if (inserted != i) {
180+ _base[inserted] = _base[i];
80181 }
81- _top -= oopSize;
82- #ifdef ASSERT
83- _base[to_index (_top)] = nullptr ;
84- #endif
85- break ;
182+ inserted++;
86183 }
87184 }
88- assert (!contains (o), " entries must be unique: " p2i (o));
185+
186+ #ifdef ASSERT
187+ for (int i = inserted; i < end; i++) {
188+ _base[i] = nullptr ;
189+ }
190+ #endif
191+
192+ uint32_t removed = end - inserted;
193+ _top -= removed * oopSize;
194+ assert (!contains (o), " entry must have been removed: " p2i (o));
89195 verify (" post-remove"
196+ return removed;
90197}
91198
92199inline bool LockStack::contains (oop o) const {
0 commit comments