Skip to content

Commit 186d04c

Browse files
GoeLinGoeLin
committedJun 30, 2023
8221372: Test vmTestbase/nsk/jvmti/GetThreadState/thrstat001/TestDescription.java times out
Update test to get rid of unneeded MethodEntry/MethodExit events Backport-of: 5df8729406fff411489c4c974a0d2a00e43d7348
·
jdk-11.0.27+4jdk-11.0.21-ga
1 parent b2d9d44 commit 186d04c

File tree

1 file changed

+64
-234
lines changed
  • test/hotspot/jtreg/vmTestbase/nsk/jvmti/GetThreadState/thrstat001

1 file changed

+64
-234
lines changed
 

‎test/hotspot/jtreg/vmTestbase/nsk/jvmti/GetThreadState/thrstat001/thrstat001.cpp

+64-234
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 2004, 2018, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 2004, 2019, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -39,177 +39,87 @@ static jvmtiEnv *jvmti = NULL;
3939
static jvmtiCapabilities caps;
4040
static jvmtiEventCallbacks callbacks;
4141
static jrawMonitorID access_lock;
42+
static jrawMonitorID wait_lock;
4243
static jint result = PASSED;
43-
static jboolean printdump = JNI_FALSE;
4444
static jthread thr_ptr = NULL;
45+
4546
static jint state[] = {
4647
JVMTI_THREAD_STATE_RUNNABLE,
4748
JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER,
4849
JVMTI_THREAD_STATE_IN_OBJECT_WAIT
4950
};
5051

51-
static int entry_count = 0;
52-
static int entry_error_count = 0;
53-
static int exit_count = 0;
54-
static int exit_error_count = 0;
55-
56-
void JNICALL VMInit(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thr) {
57-
jvmtiError err;
58-
59-
err = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
60-
JVMTI_EVENT_THREAD_START, NULL);
52+
static void
53+
lock(const char* func_name, jrawMonitorID lock) {
54+
jvmtiError err = jvmti->RawMonitorEnter(lock);
6155
if (err != JVMTI_ERROR_NONE) {
62-
printf("Failed to enable THREAD_START event: %s (%d)\n",
63-
TranslateError(err), err);
56+
printf("%s: unexpected error in RawMonitorEnter: %s (%d)\n",
57+
func_name, TranslateError(err), err);
6458
result = STATUS_FAILED;
6559
}
66-
67-
if (caps.can_generate_method_entry_events) {
68-
err = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
69-
JVMTI_EVENT_METHOD_ENTRY, NULL);
70-
if (err != JVMTI_ERROR_NONE) {
71-
printf("Failed to enable METHOD_ENTRY event: %s (%d)\n",
72-
TranslateError(err), err);
73-
result = STATUS_FAILED;
74-
}
75-
}
76-
77-
if (caps.can_generate_method_exit_events) {
78-
err = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE,
79-
JVMTI_EVENT_METHOD_EXIT, NULL);
80-
if (err != JVMTI_ERROR_NONE) {
81-
printf("Failed to enable METHOD_EXIT event: %s (%d)\n",
82-
TranslateError(err), err);
83-
result = STATUS_FAILED;
84-
}
85-
}
8660
}
8761

88-
void JNICALL
89-
ThreadStart(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread) {
90-
jvmtiError err;
91-
jvmtiThreadInfo thrInfo;
92-
93-
err = jvmti_env->RawMonitorEnter(access_lock);
94-
if (err != JVMTI_ERROR_NONE) {
95-
printf("(RawMonitorEnter#TS) unexpected error: %s (%d)\n",
96-
TranslateError(err), err);
97-
result = STATUS_FAILED;
98-
}
99-
100-
err = jvmti_env->GetThreadInfo(thread, &thrInfo);
101-
if (err != JVMTI_ERROR_NONE) {
102-
printf("(GetThreadInfo#TS) unexpected error: %s (%d)\n",
103-
TranslateError(err), err);
104-
result = STATUS_FAILED;
105-
}
106-
if (thrInfo.name != NULL && strcmp(thrInfo.name, "thr1") == 0) {
107-
thr_ptr = env->NewGlobalRef(thread);
108-
if (printdump == JNI_TRUE) {
109-
printf(">>> ThreadStart: \"%s\", 0x%p\n", thrInfo.name, thr_ptr);
110-
}
111-
}
112-
113-
err = jvmti_env->RawMonitorExit(access_lock);
62+
static void
63+
unlock(const char* func_name, jrawMonitorID lock) {
64+
jvmtiError err = jvmti->RawMonitorExit(lock);
11465
if (err != JVMTI_ERROR_NONE) {
115-
printf("(RawMonitorExit#TS) unexpected error: %s (%d)\n",
116-
TranslateError(err), err);
66+
printf("%s: unexpected error in RawMonitorExit: %s (%d)\n",
67+
func_name, TranslateError(err), err);
11768
result = STATUS_FAILED;
11869
}
11970
}
12071

121-
void JNICALL MethodEntry(jvmtiEnv *jvmti_env, JNIEnv *env,
122-
jthread thread, jmethodID mid) {
123-
jvmtiError err;
124-
jvmtiThreadInfo thrInfo;
125-
jint thrState;
126-
127-
err = jvmti_env->RawMonitorEnter(access_lock);
72+
static void
73+
wait(const char* func_name, jrawMonitorID lock, jint millis) {
74+
jvmtiError err = jvmti->RawMonitorWait(lock, (jlong)millis);
12875
if (err != JVMTI_ERROR_NONE) {
129-
printf("(RawMonitorEnter#ME) unexpected error: %s (%d)\n",
130-
TranslateError(err), err);
76+
printf("%s: unexpected error in RawMonitorWait: %s (%d)\n",
77+
func_name, TranslateError(err), err);
13178
result = STATUS_FAILED;
13279
}
80+
}
13381

134-
entry_count++;
135-
err = jvmti_env->GetThreadState(thread, &thrState);
136-
if (err != JVMTI_ERROR_NONE) {
137-
printf("(GetThreadState#ME) unexpected error: %s (%d)\n",
138-
TranslateError(err), err);
139-
result = STATUS_FAILED;
140-
}
141-
if ((thrState & JVMTI_THREAD_STATE_RUNNABLE) == 0) {
142-
if (entry_error_count == 0) {
143-
err = jvmti_env->GetThreadInfo(thread, &thrInfo);
144-
if (err != JVMTI_ERROR_NONE) {
145-
printf("(GetThreadInfo#ME) unexpected error: %s (%d)\n",
146-
TranslateError(err), err);
147-
result = STATUS_FAILED;
148-
}
149-
printf("Wrong thread \"%s\" state on MethodEntry event:\n",
150-
thrInfo.name);
151-
printf(" expected: JVMTI_THREAD_STATE_RUNNABLE\n");
152-
printf(" got: %s (%d)\n",
153-
TranslateState(thrState), thrState);
154-
}
155-
entry_error_count++;
156-
result = STATUS_FAILED;
157-
}
82+
static void
83+
set_notification_mode(const char* event_name,
84+
jvmtiEventMode mode,
85+
jvmtiEvent event_type,
86+
jthread event_thread) {
87+
const char* action = (mode == JVMTI_ENABLE) ? "enable" : "disable";
88+
jvmtiError err = jvmti->SetEventNotificationMode(mode, event_type, event_thread);
15889

159-
err = jvmti_env->RawMonitorExit(access_lock);
16090
if (err != JVMTI_ERROR_NONE) {
161-
printf("(RawMonitorExit#ME) unexpected error: %s (%d)\n",
162-
TranslateError(err), err);
91+
printf("Failed to %s %s event: %s (%d)\n",
92+
action, event_name, TranslateError(err), err);
16393
result = STATUS_FAILED;
16494
}
95+
}
16596

97+
void JNICALL VMInit(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thr) {
98+
set_notification_mode("JVMTI_EVENT_THREAD_START", JVMTI_ENABLE,
99+
JVMTI_EVENT_THREAD_START, NULL);
166100
}
167101

168-
void JNICALL MethodExit(jvmtiEnv *jvmti_env, JNIEnv *env,
169-
jthread thread, jmethodID mid,
170-
jboolean was_poped_by_exception, jvalue return_value) {
102+
void JNICALL
103+
ThreadStart(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread) {
171104
jvmtiError err;
172105
jvmtiThreadInfo thrInfo;
173-
jint thrState;
174106

175-
err = jvmti_env->RawMonitorEnter(access_lock);
176-
if (err != JVMTI_ERROR_NONE) {
177-
printf("(RawMonitorEnter#MX) unexpected error: %s (%d)\n",
178-
TranslateError(err), err);
179-
result = STATUS_FAILED;
180-
}
107+
lock("ThreadStart", access_lock);
181108

182-
exit_count++;
183-
err = jvmti_env->GetThreadState(thread, &thrState);
109+
err = jvmti_env->GetThreadInfo(thread, &thrInfo);
184110
if (err != JVMTI_ERROR_NONE) {
185-
printf("(GetThreadState#MX) unexpected error: %s (%d)\n",
186-
TranslateError(err), err);
111+
printf("(GetThreadInfo#TS) unexpected error: %s (%d)\n",
112+
TranslateError(err), err);
187113
result = STATUS_FAILED;
188114
}
189-
if ((thrState & JVMTI_THREAD_STATE_RUNNABLE) == 0) {
190-
if (exit_error_count == 0) {
191-
err = jvmti_env->GetThreadInfo(thread, &thrInfo);
192-
if (err != JVMTI_ERROR_NONE) {
193-
printf("(GetThreadInfo#MX) unexpected error: %s (%d)\n",
194-
TranslateError(err), err);
195-
result = STATUS_FAILED;
196-
}
197-
printf("Wrong thread \"%s\" state on MethodExit event:\n",
198-
thrInfo.name);
199-
printf(" expected: JVMTI_THREAD_STATE_RUNNABLE\n");
200-
printf(" got: %s (%d)\n",
201-
TranslateState(thrState), thrState);
202-
}
203-
exit_error_count++;
204-
result = STATUS_FAILED;
115+
if (thrInfo.name != NULL && strcmp(thrInfo.name, "thr1") == 0) {
116+
thr_ptr = env->NewGlobalRef(thread);
117+
printf(">>> ThreadStart: \"%s\", 0x%p\n", thrInfo.name, thr_ptr);
118+
set_notification_mode("JVMTI_EVENT_THREAD_START", JVMTI_DISABLE,
119+
JVMTI_EVENT_THREAD_START, NULL);
205120
}
206121

207-
err = jvmti_env->RawMonitorExit(access_lock);
208-
if (err != JVMTI_ERROR_NONE) {
209-
printf("(RawMonitorExit#MX) unexpected error: %s (%d)\n",
210-
TranslateError(err), err);
211-
result = STATUS_FAILED;
212-
}
122+
unlock("ThreadStart", access_lock);
213123
}
214124

215125
#ifdef STATIC_BUILD
@@ -223,13 +133,12 @@ JNIEXPORT jint JNI_OnLoad_thrstat001(JavaVM *jvm, char *options, void *reserved)
223133
return JNI_VERSION_1_8;
224134
}
225135
#endif
136+
226137
jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
227138
jint res;
228139
jvmtiError err;
229140

230-
if (options != NULL && strcmp(options, "printdump") == 0) {
231-
printdump = JNI_TRUE;
232-
}
141+
printf("Agent_Initialize started\n");
233142

234143
res = jvm->GetEnv((void **) &jvmti, JVMTI_VERSION_1_1);
235144
if (res != JNI_OK || jvmti == NULL) {
@@ -260,49 +169,42 @@ jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
260169

261170
err = jvmti->CreateRawMonitor("_access_lock", &access_lock);
262171
if (err != JVMTI_ERROR_NONE) {
263-
printf("(CreateRawMonitor) unexpected error: %s (%d)\n",
172+
printf("(CreateRawMonitor)#access_lock unexpected error: %s (%d)\n",
173+
TranslateError(err), err);
174+
return JNI_ERR;
175+
}
176+
177+
err = jvmti->CreateRawMonitor("_wait_lock", &wait_lock);
178+
if (err != JVMTI_ERROR_NONE) {
179+
printf("(CreateRawMonitor#wait_lock) unexpected error: %s (%d)\n",
264180
TranslateError(err), err);
265181
return JNI_ERR;
266182
}
267183

268184
callbacks.VMInit = &VMInit;
269185
callbacks.ThreadStart = &ThreadStart;
270-
if (caps.can_generate_method_entry_events) {
271-
callbacks.MethodEntry = &MethodEntry;
272-
} else {
273-
printf("Warning: MethodEntry event is not implemented\n");
274-
}
275-
if (caps.can_generate_method_exit_events) {
276-
callbacks.MethodExit = &MethodExit;
277-
} else {
278-
printf("Warning: MethodExit event is not implemented\n");
279-
}
280186
err = jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks));
281187
if (err != JVMTI_ERROR_NONE) {
282188
printf("(SetEventCallbacks) unexpected error: %s (%d)\n",
283189
TranslateError(err), err);
284190
return JNI_ERR;
285191
}
286192

287-
err = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
288-
JVMTI_EVENT_VM_INIT, NULL);
289-
if (err != JVMTI_ERROR_NONE) {
290-
printf("Failed to enable VM_INIT event: %s (%d)\n",
291-
TranslateError(err), err);
292-
result = STATUS_FAILED;
293-
}
193+
set_notification_mode("JVMTI_EVENT_VM_INIT", JVMTI_ENABLE,
194+
JVMTI_EVENT_VM_INIT, NULL);
294195

196+
printf("Agent_Initialize finished\n\n");
295197
return JNI_OK;
296198
}
297199

298200
JNIEXPORT void JNICALL
299201
Java_nsk_jvmti_GetThreadState_thrstat001_checkStatus(JNIEnv *env,
300202
jclass cls, jint statInd) {
301203
jvmtiError err;
302-
jrawMonitorID wait_lock;
303204
jint thrState;
304205
jint millis;
305206

207+
printf("native method checkStatus started\n");
306208
if (jvmti == NULL) {
307209
printf("JVMTI client was not properly loaded!\n");
308210
result = STATUS_FAILED;
@@ -316,12 +218,6 @@ Java_nsk_jvmti_GetThreadState_thrstat001_checkStatus(JNIEnv *env,
316218
}
317219

318220
/* wait until thread gets an expected state */
319-
err = jvmti->CreateRawMonitor("_wait_lock", &wait_lock);
320-
if (err != JVMTI_ERROR_NONE) {
321-
printf("(CreateRawMonitor) unexpected error: %s (%d)\n",
322-
TranslateError(err), err);
323-
result = STATUS_FAILED;
324-
}
325221
for (millis = WAIT_START; millis < WAIT_TIME; millis <<= 1) {
326222
err = jvmti->GetThreadState(thr_ptr, &thrState);
327223
if (err != JVMTI_ERROR_NONE) {
@@ -332,36 +228,13 @@ Java_nsk_jvmti_GetThreadState_thrstat001_checkStatus(JNIEnv *env,
332228
if ((thrState & state[statInd]) != 0) {
333229
break;
334230
}
335-
err = jvmti->RawMonitorEnter(wait_lock);
336-
if (err != JVMTI_ERROR_NONE) {
337-
printf("(RawMonitorEnter) unexpected error: %s (%d)\n",
338-
TranslateError(err), err);
339-
result = STATUS_FAILED;
340-
}
341-
err = jvmti->RawMonitorWait(wait_lock, (jlong)millis);
342-
if (err != JVMTI_ERROR_NONE) {
343-
printf("(RawMonitorWait) unexpected error: %s (%d)\n",
344-
TranslateError(err), err);
345-
result = STATUS_FAILED;
346-
}
347-
err = jvmti->RawMonitorExit(wait_lock);
348-
if (err != JVMTI_ERROR_NONE) {
349-
printf("(RawMonitorExit) unexpected error: %s (%d)\n",
350-
TranslateError(err), err);
351-
result = STATUS_FAILED;
352-
}
353-
}
354-
err = jvmti->DestroyRawMonitor(wait_lock);
355-
if (err != JVMTI_ERROR_NONE) {
356-
printf("(DestroyRawMonitor) unexpected error: %s (%d)\n",
357-
TranslateError(err), err);
358-
result = STATUS_FAILED;
231+
lock("checkStatus", wait_lock);
232+
wait("checkStatus", wait_lock, millis);
233+
unlock("checkStatus", wait_lock);
359234
}
360235

361-
if (printdump == JNI_TRUE) {
362-
printf(">>> thread \"thr1\" (0x%p) state: %s (%d)\n",
236+
printf(">>> thread \"thr1\" (0x%p) state: %s (%d)\n",
363237
thr_ptr, TranslateState(thrState), thrState);
364-
}
365238

366239
if ((thrState & state[statInd]) == 0) {
367240
printf("Wrong thread \"thr1\" (0x%p) state:\n", thr_ptr);
@@ -371,55 +244,12 @@ Java_nsk_jvmti_GetThreadState_thrstat001_checkStatus(JNIEnv *env,
371244
TranslateState(thrState), thrState);
372245
result = STATUS_FAILED;
373246
}
247+
printf("native method checkStatus finished\n\n");
374248
}
375249

376250
JNIEXPORT jint JNICALL
377251
Java_nsk_jvmti_GetThreadState_thrstat001_getRes(JNIEnv *env, jclass cls) {
378-
jvmtiError err;
379-
380-
err = jvmti->SetEventNotificationMode(JVMTI_DISABLE,
381-
JVMTI_EVENT_THREAD_START, NULL);
382-
if (err != JVMTI_ERROR_NONE) {
383-
printf("Failed to disable THREAD_START event: %s (%d)\n",
384-
TranslateError(err), err);
385-
result = STATUS_FAILED;
386-
}
387-
388-
if (caps.can_generate_method_entry_events) {
389-
err = jvmti->SetEventNotificationMode(JVMTI_DISABLE,
390-
JVMTI_EVENT_METHOD_ENTRY, NULL);
391-
if (err != JVMTI_ERROR_NONE) {
392-
printf("Failed to disable METHOD_ENTRY event: %s (%d)\n",
393-
TranslateError(err), err);
394-
result = STATUS_FAILED;
395-
}
396-
}
397-
398-
if (caps.can_generate_method_exit_events) {
399-
err = jvmti->SetEventNotificationMode(JVMTI_DISABLE,
400-
JVMTI_EVENT_METHOD_EXIT, NULL);
401-
if (err != JVMTI_ERROR_NONE) {
402-
printf("Failed to disable METHOD_EXIT event: %s (%d)\n",
403-
TranslateError(err), err);
404-
result = STATUS_FAILED;
405-
}
406-
}
407-
408-
if (printdump == JNI_TRUE) {
409-
printf(">>> total number of method entry events = %d\n", entry_count);
410-
printf(">>> total number of method exit events = %d\n", exit_count);
411-
}
412-
413-
if (entry_error_count != 0) {
414-
printf("Total number of errors on METHOD_ENTRY: %d of %d events\n",
415-
entry_error_count, entry_count);
416-
}
417-
418-
if (exit_error_count != 0) {
419-
printf("Total number of errors on METHOD_EXIT: %d of %d events\n",
420-
exit_error_count, exit_count);
421-
}
422-
252+
printf("native method getRes: result: %d\n\n", result);
423253
return result;
424254
}
425255

0 commit comments

Comments
 (0)
Please sign in to comment.