stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8316456: StackWalker may skip Continuation::yield0 frame mistakenly

Browse Source 
Reviewed-by: rpressler, pchilanomate
This commit is contained in:
Mandy Chung 2023-09-21 23:10:49 +00:00
parent 041510dc21
commit c72f00463f
7 changed files with 152 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/hotspot/share/include/jvm.h
View File

@ -255,11 +255,11 @@ JVM_ExpandStackFrameInfo(JNIEnv *env, jobject obj);
JNIEXPORT jobject JNICALL
JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
jint skip_frames, jobject contScope, jobject cont,
jint frame_count, jint start_index, jobjectArray frames);
jint buffer_size, jint start_index, jobjectArray frames);
JNIEXPORT jint JNICALL
JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
jint frame_count, jint start_index,
jint last_batch_count, jint buffer_size, jint start_index,
jobjectArray frames);
JNIEXPORT void JNICALL

14
src/hotspot/share/prims/jvm.cpp
View File

@ -565,7 +565,7 @@ JVM_END
JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode,
jint skip_frames, jobject contScope, jobject cont,
jint frame_count, jint start_index, jobjectArray frames))
jint buffer_size, jint start_index, jobjectArray frames))
if (!thread->has_last_Java_frame()) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", nullptr);
}
@ -579,19 +579,18 @@ JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jint mode
objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
objArrayHandle frames_array_h(THREAD, fa);
int limit = start_index + frame_count;
if (frames_array_h->length() < limit) {
if (frames_array_h->length() < buffer_size) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", nullptr);
}
oop result = StackWalk::walk(stackStream_h, mode, skip_frames, contScope_h, cont_h,
frame_count, start_index, frames_array_h, CHECK_NULL);
buffer_size, start_index, frames_array_h, CHECK_NULL);
return JNIHandles::make_local(THREAD, result);
JVM_END
JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, jlong anchor,
jint frame_count, jint start_index,
jint last_batch_count, jint buffer_size, jint start_index,
jobjectArray frames))
// frames array is a ClassFrameInfo[] array when only getting caller reference,
// and a StackFrameInfo[] array (or derivative) otherwise. It should never
@ -599,13 +598,12 @@ JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jint mode, j
objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));
objArrayHandle frames_array_h(THREAD, fa);
int limit = start_index+frame_count;
if (frames_array_h->length() < limit) {
if (frames_array_h->length() < buffer_size) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");
}
Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));
return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,
return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, last_batch_count, buffer_size,
start_index, frames_array_h, THREAD);
JVM_END

119
src/hotspot/share/prims/stackwalk.cpp
View File

@ -152,7 +152,7 @@ BaseFrameStream* BaseFrameStream::from_current(JavaThread* thread, jlong magic,
// Parameters:
// mode Restrict which frames to be decoded.
// BaseFrameStream stream of frames
// max_nframes Maximum number of frames to be filled.
// buffer_size Buffer size
// start_index Start index to the user-supplied buffers.
// frames_array Buffer to store stack frame information in, starting at start_index.
// frames array is a ClassFrameInfo[] array when only getting caller
@ -163,13 +163,13 @@ BaseFrameStream* BaseFrameStream::from_current(JavaThread* thread, jlong magic,
// Returns the number of frames whose information was transferred into the buffers.
//
int StackWalk::fill_in_frames(jint mode, BaseFrameStream& stream,
int max_nframes, int start_index,
int buffer_size, int start_index,
objArrayHandle frames_array,
int& end_index, TRAPS) {
log_debug(stackwalk)("fill_in_frames limit=%d start=%d frames length=%d",
max_nframes, start_index, frames_array->length());
assert(max_nframes > 0, "invalid max_nframes");
assert(start_index + max_nframes <= frames_array->length(), "oob");
buffer_size, start_index, frames_array->length());
assert(buffer_size > 0, "invalid buffer_size");
assert(buffer_size <= frames_array->length(), "oob");
int frames_decoded = 0;
for (; !stream.at_end(); stream.next()) {
@ -186,49 +186,27 @@ int StackWalk::fill_in_frames(jint mode, BaseFrameStream& stream,
// skip hidden frames for default StackWalker option (i.e. SHOW_HIDDEN_FRAMES
// not set) and when StackWalker::getCallerClass is called
LogTarget(Debug, stackwalk) lt;
if (!ShowHiddenFrames && skip_hidden_frames(mode)) {
if (method->is_hidden()) {
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
LogStream ls(lt);
ls.print(" skip hidden method: ");
method->print_short_name(&ls);
ls.cr();
}
log_debug(stackwalk)(" skip hidden method: %s", stream.method()->external_name());
// We end a batch on continuation bottom to let the Java side skip top frames of the next one
// End a batch on continuation bottom to let the Java side to set the continuation to its parent and continue
if (stream.continuation() != nullptr && method->intrinsic_id() == vmIntrinsics::_Continuation_enter) break;
continue;
}
}
int index = end_index++;
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
LogStream ls(lt);
ls.print(" %d: frame method: ", index);
method->print_short_name(&ls);
ls.print_cr(" bci=%d", stream.bci());
}
// fill in StackFrameInfo and initialize MemberName
log_debug(stackwalk)(" frame %d: %s bci %d", index, stream.method()->external_name(), stream.bci());
stream.fill_frame(index, frames_array, methodHandle(THREAD, method), CHECK_0);
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
LogStream ls(lt);
ls.print(" %d: done frame method: ", index);
method->print_short_name(&ls);
}
frames_decoded++;
// We end a batch on continuation bottom to let the Java side skip top frames of the next one
// End a batch on continuation bottom to let the Java side to set the continuation to its parent and continue
if (stream.continuation() != nullptr && method->intrinsic_id() == vmIntrinsics::_Continuation_enter) break;
if (frames_decoded >= max_nframes) break;
if (end_index >= buffer_size) break;
}
log_debug(stackwalk)("fill_in_frames done frames_decoded=%d at_end=%d", frames_decoded, stream.at_end());
log_debug(stackwalk)("fill_in_frames returns %d at_end=%d", frames_decoded, stream.at_end());
return frames_decoded;
}
@ -398,7 +376,7 @@ void LiveFrameStream::fill_live_stackframe(Handle stackFrame,
// mode Stack walking mode.
// skip_frames Number of frames to be skipped.
// cont_scope Continuation scope to walk (if not in this scope, we'll walk all the way).
// frame_count Number of frames to be traversed.
// buffer_size Buffer size.
// start_index Start index to the user-supplied buffers.
// frames_array Buffer to store stack frame info in, starting at start_index.
// frames array is a ClassFrameInfo[] array when only getting caller
@ -408,13 +386,13 @@ void LiveFrameStream::fill_live_stackframe(Handle stackFrame,
// Returns Object returned from AbstractStackWalker::doStackWalk call.
//
oop StackWalk::walk(Handle stackStream, jint mode, int skip_frames, Handle cont_scope, Handle cont,
int frame_count, int start_index, objArrayHandle frames_array,
int buffer_size, int start_index, objArrayHandle frames_array,
TRAPS) {
ResourceMark rm(THREAD);
HandleMark hm(THREAD); // needed to store a continuation in the RegisterMap
JavaThread* jt = THREAD;
log_debug(stackwalk)("Start walking: mode " INT32_FORMAT_X " skip %d frames batch size %d", mode, skip_frames, frame_count);
log_debug(stackwalk)("Start walking: mode " INT32_FORMAT_X " skip %d frames, buffer size %d", mode, skip_frames, buffer_size);
LogTarget(Debug, stackwalk) lt;
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
@ -438,17 +416,17 @@ oop StackWalk::walk(Handle stackStream, jint mode, int skip_frames, Handle cont_
RegisterMap::WalkContinuation::include)
: RegisterMap(cont(), RegisterMap::UpdateMap::include);
LiveFrameStream stream(jt, &regMap, cont_scope, cont);
return fetchFirstBatch(stream, stackStream, mode, skip_frames, frame_count,
return fetchFirstBatch(stream, stackStream, mode, skip_frames, buffer_size,
start_index, frames_array, THREAD);
} else {
JavaFrameStream stream(jt, mode, cont_scope, cont);
return fetchFirstBatch(stream, stackStream, mode, skip_frames, frame_count,
return fetchFirstBatch(stream, stackStream, mode, skip_frames, buffer_size,
start_index, frames_array, THREAD);
}
}
oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
jint mode, int skip_frames, int frame_count,
jint mode, int skip_frames, int buffer_size,
int start_index, objArrayHandle frames_array, TRAPS) {
methodHandle m_doStackWalk(THREAD, Universe::do_stack_walk_method());
@ -461,29 +439,14 @@ oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
ik != abstractStackWalker_klass && ik->super() != abstractStackWalker_klass) {
break;
}
LogTarget(Debug, stackwalk) lt;
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
LogStream ls(lt);
ls.print(" skip ");
stream.method()->print_short_name(&ls);
ls.cr();
}
log_debug(stackwalk)(" skip %s", stream.method()->external_name());
stream.next();
}
// stack frame has been traversed individually and resume stack walk
// from the stack frame at depth == skip_frames.
for (int n=0; n < skip_frames && !stream.at_end(); stream.next(), n++) {
LogTarget(Debug, stackwalk) lt;
if (lt.is_enabled()) {
ResourceMark rm(THREAD);
LogStream ls(lt);
ls.print(" skip ");
stream.method()->print_short_name(&ls);
ls.cr();
}
log_debug(stackwalk)(" skip %s", stream.method()->external_name());
}
}
@ -491,7 +454,7 @@ oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
int numFrames = 0;
if (!stream.at_end()) {
KeepStackGCProcessedMark keep_stack(THREAD);
numFrames = fill_in_frames(mode, stream, frame_count, start_index,
numFrames = fill_in_frames(mode, stream, buffer_size, start_index,
frames_array, end_index, CHECK_NULL);
if (numFrames < 1) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "stack walk: decode failed", nullptr);
@ -506,7 +469,7 @@ oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
JavaCallArguments args(stackStream);
args.push_long(stream.address_value());
args.push_int(skip_frames);
args.push_int(frame_count);
args.push_int(numFrames);
args.push_int(start_index);
args.push_int(end_index);
@ -535,14 +498,15 @@ oop StackWalk::fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
// stackStream StackStream object
// mode Stack walking mode.
// magic Must be valid value to continue the stack walk
// frame_count Number of frames to be decoded.
// last_batch_count Number of frames fetched in the last batch.
// buffer_size Buffer size.
// start_index Start index to the user-supplied buffers.
// frames_array Buffer to store StackFrame in, starting at start_index.
//
// Returns the end index of frame filled in the buffer.
// Returns the number of frames filled in the buffer.
//
jint StackWalk::fetchNextBatch(Handle stackStream, jint mode, jlong magic,
int frame_count, int start_index,
int last_batch_count, int buffer_size, int start_index,
objArrayHandle frames_array,
TRAPS)
{
@ -556,16 +520,15 @@ jint StackWalk::fetchNextBatch(Handle stackStream, jint mode, jlong magic,
THROW_MSG_(vmSymbols::java_lang_NullPointerException(), "frames_array is null", 0L);
}
log_debug(stackwalk)("StackWalk::fetchNextBatch frame_count %d existing_stream "
PTR_FORMAT " start %d frames %d",
frame_count, p2i(existing_stream), start_index, frames_array->length());
log_debug(stackwalk)("StackWalk::fetchNextBatch last_batch_count %d buffer_size %d existing_stream "
PTR_FORMAT " start %d", last_batch_count,
buffer_size, p2i(existing_stream), start_index, frames_array->length());
int end_index = start_index;
if (frame_count <= 0) {
return end_index; // No operation.
if (buffer_size <= start_index) {
return 0; // No operation.
}
int count = frame_count + start_index;
assert (frames_array->length() >= count, "not enough space in buffers");
assert (frames_array->length() >= buffer_size, "frames_array length < buffer_size");
BaseFrameStream& stream = (*existing_stream);
if (!stream.at_end()) {
@ -574,17 +537,27 @@ jint StackWalk::fetchNextBatch(Handle stackStream, jint mode, jlong magic,
// peeking at a few frames. Take the cost of flushing out any pending deferred GC
// processing of the stack.
KeepStackGCProcessedMark keep_stack(jt);
stream.next(); // advance past the last frame decoded in previous batch
// Advance past the last frame decoded in the previous batch.
// If the last batch is empty, it means that the last batch returns after
// it advanced the frame it previously decoded as it reaches the bottom of
// the continuation and it returns to let Java side set the continuation.
// Now this batch starts right at the first frame of another continuation.
if (last_batch_count > 0) {
log_debug(stackwalk)("advanced past %s", stream.method()->external_name());
stream.next();
}
if (!stream.at_end()) {
int n = fill_in_frames(mode, stream, frame_count, start_index,
int numFrames = fill_in_frames(mode, stream, buffer_size, start_index,
frames_array, end_index, CHECK_0);
if (n < 1 && !skip_hidden_frames(mode)) {
if (numFrames < 1 && !skip_hidden_frames(mode)) {
THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: later decode failed", 0L);
}
return end_index;
return numFrames;
}
}
return end_index;
return 0;
}
void StackWalk::setContinuation(Handle stackStream, jlong magic, objArrayHandle frames_array, Handle cont, TRAPS) {

8
src/hotspot/share/prims/stackwalk.hpp
View File

@ -143,7 +143,7 @@ public:
class StackWalk : public AllStatic {
private:
static int fill_in_frames(jint mode, BaseFrameStream& stream,
int max_nframes, int start_index,
int buffer_size, int start_index,
objArrayHandle frames_array,
int& end_index, TRAPS);
@ -160,15 +160,15 @@ public:
}
static oop walk(Handle stackStream, jint mode, int skip_frames, Handle cont_scope, Handle cont,
int frame_count, int start_index, objArrayHandle frames_array,
int buffer_size, int start_index, objArrayHandle frames_array,
TRAPS);
static oop fetchFirstBatch(BaseFrameStream& stream, Handle stackStream,
jint mode, int skip_frames, int frame_count,
jint mode, int skip_frames, int buffer_size,
int start_index, objArrayHandle frames_array, TRAPS);
static jint fetchNextBatch(Handle stackStream, jint mode, jlong magic,
int frame_count, int start_index,
int last_batch_count, int buffer_size, int start_index,
objArrayHandle frames_array, TRAPS);
static void setContinuation(Handle stackStream, jlong magic, objArrayHandle frames_array,

147
src/java.base/share/classes/java/lang/StackStreamFactory.java
View File

@ -192,10 +192,10 @@ final class StackStreamFactory {
*
* Subclass should override this method to change the batch size
*
* @param lastBatchFrameCount number of frames in the last batch; or zero
* @param lastBatchSize last batch size
* @return suggested batch size
*/
protected abstract int batchSize(int lastBatchFrameCount);
protected abstract int batchSize(int lastBatchSize);
/*
* Returns the next batch size, always >= minimum batch size
@ -203,7 +203,7 @@ final class StackStreamFactory {
* Subclass may override this method if the minimum batch size is different.
*/
protected int getNextBatchSize() {
int lastBatchSize = depth == 0 ? 0 : frameBuffer.curBatchFrameCount();
int lastBatchSize = depth == 0 ? 0 : frameBuffer.currentBatchSize();
int nextBatchSize = batchSize(lastBatchSize);
if (isDebug) {
System.err.println("last batch size = " + lastBatchSize +
@ -312,19 +312,19 @@ final class StackStreamFactory {
* 2. reuse or expand the allocated buffers
* 3. create specialized StackFrame objects
*/
private Object doStackWalk(long anchor, int skipFrames, int batchSize,
private Object doStackWalk(long anchor, int skipFrames, int numFrames,
int bufStartIndex, int bufEndIndex) {
checkState(NEW);
frameBuffer.check(skipFrames);
if (isDebug) {
System.err.format("doStackWalk: skip %d start %d end %d%n",
skipFrames, bufStartIndex, bufEndIndex);
System.err.format("doStackWalk: skip %d start %d end %d nframes %d%n",
skipFrames, bufStartIndex, bufEndIndex, numFrames);
}
this.anchor = anchor; // set anchor for this bulk stack frame traversal
frameBuffer.setBatch(depth, bufStartIndex, bufEndIndex);
frameBuffer.setBatch(depth, bufStartIndex, numFrames);
// traverse all frames and perform the action on the stack frames, if specified
return consumeFrames();
@ -334,10 +334,8 @@ final class StackStreamFactory {
* Get next batch of stack frames.
*/
private int getNextBatch() {
int nextBatchSize = Math.min(maxDepth - depth, getNextBatchSize());
if (!frameBuffer.isActive()
|| (nextBatchSize <= 0)
|| (depth == maxDepth)
|| (frameBuffer.isAtBottom() && !hasMoreContinuations())) {
if (isDebug) {
System.out.format(" more stack walk done%n");
@ -346,11 +344,21 @@ final class StackStreamFactory {
return 0;
}
// VM ends the batch when it reaches the bottom of a continuation
// i.e. Continuation::enter. The stack walker will set the continuation
// to its parent to continue.
// Note that the current batch could have no stack frame filled. This could
// happen when Continuation::enter is the last element of the frame buffer
// filled in the last batch and it needs to fetch another batch in order to
// detect reaching the bottom.
if (frameBuffer.isAtBottom() && hasMoreContinuations()) {
if (isDebug) {
System.out.format(" set continuation to %s%n", continuation.getParent());
}
setContinuation(continuation.getParent());
}
int numFrames = fetchStackFrames(nextBatchSize);
int numFrames = fetchStackFrames();
if (numFrames == 0 && !hasMoreContinuations()) {
frameBuffer.freeze(); // done stack walking
}
@ -415,34 +423,35 @@ final class StackStreamFactory {
return callStackWalk(mode, 0,
contScope, continuation,
frameBuffer.curBatchFrameCount(),
frameBuffer.currentBatchSize(),
frameBuffer.startIndex(),
frameBuffer.frames());
}
/*
* Fetches stack frames.
* Fetches a new batch of stack frames. This method returns
* the number of stack frames filled in this batch.
*
* @param batchSize number of elements of the frame buffers for this batch
* @return number of frames fetched in this batch
* When it reaches the bottom of a continuation, i.e. Continuation::enter,
* VM ends the batch and let the stack walker to set the continuation
* to its parent and continue the stack walking. It may return zero.
*/
private int fetchStackFrames(int batchSize) {
private int fetchStackFrames() {
int startIndex = frameBuffer.startIndex();
frameBuffer.resize(startIndex, batchSize);
int endIndex = fetchStackFrames(mode, anchor, batchSize,
startIndex,
// If the last batch didn't fetch any frames, keep the current batch size.
int lastBatchFrameCount = frameBuffer.numFrames();
int batchSize = getNextBatchSize();
frameBuffer.resize(batchSize);
int numFrames = fetchStackFrames(mode, anchor, lastBatchFrameCount,
batchSize, startIndex,
frameBuffer.frames());
if (isDebug) {
System.out.format(" more stack walk requesting %d got %d to %d frames%n",
batchSize, frameBuffer.startIndex(), endIndex);
}
int numFrames = endIndex - startIndex;
if (numFrames > 0) {
frameBuffer.setBatch(depth, startIndex, endIndex);
System.out.format(" more stack walk got %d frames start %d batch size %d%n",
numFrames, frameBuffer.startIndex(), batchSize);
}
frameBuffer.setBatch(depth, startIndex, numFrames);
return numFrames;
}
@ -454,7 +463,7 @@ final class StackStreamFactory {
* @param skipframes number of frames to be skipped before filling the frame buffer.
* @param contScope the continuation scope to walk.
* @param continuation the continuation to walk, or {@code null} if walking a thread.
* @param batchSize the batch size, max. number of elements to be filled in the frame buffers.
* @param bufferSize the buffer size
* @param startIndex start index of the frame buffers to be filled.
* @param frames Either a {@link ClassFrameInfo} array, if mode is {@link #CLASS_INFO_ONLY}
* or a {@link StackFrameInfo} (or derivative) array otherwise.
@ -462,7 +471,7 @@ final class StackStreamFactory {
*/
private native R callStackWalk(int mode, int skipframes,
ContinuationScope contScope, Continuation continuation,
int batchSize, int startIndex,
int bufferSize, int startIndex,
T[] frames);
/**
@ -470,15 +479,16 @@ final class StackStreamFactory {
*
* @param mode mode of stack walking
* @param anchor
* @param batchSize the batch size, max. number of elements to be filled in the frame buffers.
* @param lastBatchFrameCount the number of frames filled in the last batch.
* @param bufferSize the buffer size
* @param startIndex start index of the frame buffers to be filled.
* @param frames Either a {@link ClassFrameInfo} array, if mode is {@link #CLASS_INFO_ONLY}
* or a {@link StackFrameInfo} (or derivative) array otherwise.
*
* @return the end index to the frame buffers
* @return the number of frames filled in this batch
*/
private native int fetchStackFrames(int mode, long anchor,
int batchSize, int startIndex,
private native int fetchStackFrames(int mode, long anchor, int lastBatchFrameCount,
int bufferSize, int startIndex,
T[] frames);
private native void setContinuation(long anchor, T[] frames, Continuation cont);
@ -537,16 +547,18 @@ final class StackStreamFactory {
}
@Override
protected int batchSize(int lastBatchFrameCount) {
if (lastBatchFrameCount == 0) {
protected int batchSize(int lastBatchSize) {
if (lastBatchSize == 0) {
// First batch, use estimateDepth if not exceed the large batch size
int initialBatchSize = Math.max(walker.estimateDepth()+RESERVED_ELEMENTS, MIN_BATCH_SIZE);
return Math.min(initialBatchSize, LARGE_BATCH_SIZE);
} else {
if (lastBatchFrameCount > BATCH_SIZE) {
return lastBatchFrameCount;
// expand only if last batch was full and the buffer size <= 32
// to minimize the number of unneeded frames decoded.
if (lastBatchSize > BATCH_SIZE || !frameBuffer.isFull()) {
return lastBatchSize;
} else {
return Math.min(lastBatchFrameCount*2, BATCH_SIZE);
return Math.min(lastBatchSize*2, BATCH_SIZE);
}
}
}
@ -638,21 +650,20 @@ final class StackStreamFactory {
}
@Override
void resize(int startIndex, int elements) {
void resize(int size) {
if (!isActive())
throw new IllegalStateException("inactive frame buffer can't be resized");
assert startIndex == START_POS :
"bad start index " + startIndex + " expected " + START_POS;
assert startIndex() == START_POS :
"bad start index " + startIndex() + " expected " + START_POS;
int size = startIndex+elements;
if (stackFrames.length < size) {
T[] newFrames = allocateArray(size);
// copy initial magic...
System.arraycopy(stackFrames, 0, newFrames, 0, startIndex);
System.arraycopy(stackFrames, 0, newFrames, 0, startIndex());
stackFrames = newFrames;
}
fill(stackFrames, startIndex, size);
fill(stackFrames, startIndex(), size);
currentBatchSize = size;
}
@ -762,7 +773,7 @@ final class StackStreamFactory {
}
@Override
protected int batchSize(int lastBatchFrameCount) {
protected int batchSize(int lastBatchSize) {
// this method is only called when the caller class is not found in
// the first batch. getCallerClass may be invoked via core reflection.
// So increase the next batch size as there may be implementation-specific
@ -803,8 +814,7 @@ final class StackStreamFactory {
// buffers for VM to fill stack frame info
int currentBatchSize; // current batch size
int origin; // index to the current traversed stack frame
int fence; // index to the last frame in the current batch
int fence; // index past the last frame of the current batch
FrameBuffer(int initialBatchSize) {
if (initialBatchSize < MIN_BATCH_SIZE) {
throw new IllegalArgumentException(initialBatchSize +
@ -830,16 +840,13 @@ final class StackStreamFactory {
/**
* Resizes the buffers for VM to fill in the next batch of stack frames.
* The next batch will start at the given startIndex with the maximum number
* of elements.
*
* <p> Subclass may override this method to manage the allocated buffers.
*
* @param startIndex the start index for the first frame of the next batch to fill in.
* @param elements the number of elements for the next batch to fill in.
* @param size new batch size
*
*/
abstract void resize(int startIndex, int elements);
abstract void resize(int size);
/**
* Return the class at the given position in the current batch.
@ -871,8 +878,8 @@ final class StackStreamFactory {
// ------ FrameBuffer implementation ------
final int curBatchFrameCount() {
return currentBatchSize-START_POS;
final int currentBatchSize() {
return currentBatchSize;
}
/*
@ -882,6 +889,15 @@ final class StackStreamFactory {
return origin >= fence || (origin == START_POS && fence == 0);
}
/*
* Returns the number of stack frames filled in the current batch
*/
final int numFrames() {
if (!isActive())
throw new IllegalStateException();
return fence - startIndex();
}
/*
* Freezes this frame buffer. The stack stream source is done fetching.
*/
@ -892,10 +908,14 @@ final class StackStreamFactory {
/*
* Tests if this frame buffer is active. It is inactive when
* it is done for traversal. All stack frames have been traversed.
* it is done for traversal.
*/
final boolean isActive() {
return origin > 0; // && (fence == 0 || origin < fence || fence == currentBatchSize);
return origin > 0;
}
final boolean isFull() {
return fence == currentBatchSize;
}
/*
@ -918,7 +938,7 @@ final class StackStreamFactory {
if (isDebug) {
int index = origin-1;
System.out.format(" next frame at %d: %s (origin %d fence %d)%n", index,
Objects.toString(c), index, fence);
c.getName(), index, fence);
}
return c;
}
@ -941,17 +961,16 @@ final class StackStreamFactory {
}
/*
* Set the start and end index of a new batch of stack frames that have
* been filled in this frame buffer.
* Set a new batch of stack frames that have been filled in this frame buffer.
*/
final void setBatch(int depth, int startIndex, int endIndex) {
if (startIndex <= 0 || endIndex <= 0)
final void setBatch(int depth, int startIndex, int numFrames) {
if (startIndex <= 0 || numFrames < 0)
throw new IllegalArgumentException("startIndex=" + startIndex
+ " endIndex=" + endIndex);
+ " numFrames=" + numFrames);
this.origin = startIndex;
this.fence = endIndex;
for (int i = START_POS; i < fence; i++) {
this.fence = startIndex + numFrames;
for (int i = startIndex; i < fence; i++) {
if (isDebug) System.err.format(" frame %d: %s%n", i, at(i));
if (depth == 0 && filterStackWalkImpl(at(i))) { // filter the frames due to the stack stream implementation
origin++;

8
src/java.base/share/native/libjava/StackStreamFactory.c
View File

@ -56,10 +56,10 @@ JNIEXPORT jboolean JNICALL Java_java_lang_StackStreamFactory_checkStackWalkModes
*/
JNIEXPORT jobject JNICALL Java_java_lang_StackStreamFactory_00024AbstractStackWalker_callStackWalk
(JNIEnv *env, jobject stackstream, jint mode, jint skipFrames, jobject contScope, jobject cont,
jint batchSize, jint startIndex, jobjectArray frames)
jint bufferSize, jint startIndex, jobjectArray frames)
{
return JVM_CallStackWalk(env, stackstream, mode, skipFrames, contScope, cont,
batchSize, startIndex, frames);
bufferSize, startIndex, frames);
}
/*
@ -69,10 +69,10 @@ JNIEXPORT jobject JNICALL Java_java_lang_StackStreamFactory_00024AbstractStackWa
*/
JNIEXPORT jint JNICALL Java_java_lang_StackStreamFactory_00024AbstractStackWalker_fetchStackFrames
(JNIEnv *env, jobject stackstream, jint mode, jlong anchor,
jint batchSize, jint startIndex,
int lastBatchFrameCount, jint bufferSize, jint startIndex,
jobjectArray frames)
{
return JVM_MoreStackWalk(env, stackstream, mode, anchor, batchSize,
return JVM_MoreStackWalk(env, stackstream, mode, anchor, lastBatchFrameCount, bufferSize,
startIndex, frames);
}

10
test/jdk/jdk/internal/vm/Continuation/Scoped.java
View File

@ -74,15 +74,15 @@ public class Scoped {
frames = cont.stackWalker().walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("No scope: " + frames);
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "yield0", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
frames = cont.stackWalker(EnumSet.noneOf(StackWalker.Option.class), A).walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("A: " + frames);
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "yield0", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
frames = cont.stackWalker(EnumSet.noneOf(StackWalker.Option.class), B).walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("B: " + frames);
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "run", "bar", "lambda$foo$8", "run", "enter0", "enter"));
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "yield0", "run", "bar", "lambda$foo$8", "run", "enter0", "enter"));
frames = cont.stackWalker(EnumSet.noneOf(StackWalker.Option.class), C).walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("C: " + frames);
@ -90,11 +90,11 @@ public class Scoped {
frames = cont.stackWalker(EnumSet.noneOf(StackWalker.Option.class), K).walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("K: " + frames);
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "yield0", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
frames = cont.stackWalker(EnumSet.noneOf(StackWalker.Option.class), null).walk(fs -> fs.map(StackWalker.StackFrame::getMethodName).collect(Collectors.toList()));
System.out.println("null: " + frames);
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
assertEquals(frames, cont.isDone() ? List.of() : Arrays.asList("yield0", "yield", "lambda$bar$14", "run", "enter0", "enter", "yield0", "run", "bar", "lambda$foo$8", "run", "enter0", "enter", "yield0", "run", "foo", "lambda$test1$0", "run", "enter0", "enter"));
}
assertEquals(res.get(), 2);
}