Index: trunk/vm/tests/unit/thread/test_java_basic.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_basic.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_basic.c (working copy) @@ -31,23 +31,35 @@ /* * Test jthread_attach() */ -void * APR_THREAD_FUNC run_for_test_jthread_attach(apr_thread_t *thread, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; - JNIEnv * jni_env = NULL; +int HYTHREAD_PROC run_for_test_jthread_attach(void *args){ + tested_thread_sturct_t * tts; + hythread_t native_thread; + JNIEnv * jni_env; IDATA status; - - //tts->jni_env = tts_jni_env; - status = jthread_attach(jni_env, tts->java_thread, JNI_FALSE); - tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_ATTACHED : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; + + tts = (tested_thread_sturct_t *) args; + native_thread = hythread_self(); + if (!native_thread) { + status = hythread_attach(&native_thread); + if (status != JNI_OK) { + tts->phase = TT_PHASE_ERROR; + return 0; } } - tts->phase = TT_PHASE_DEAD; + status = vm_attach(GLOBAL_VM, &jni_env); + if (status != JNI_OK) { + tts->phase = TT_PHASE_ERROR; + return 0; + } + + status = jthread_attach(jni_env, tts->java_thread, JNI_FALSE); + tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_ATTACHED : TT_PHASE_ERROR); + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); + status = jthread_detach(tts->java_thread); + tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); return 0; } @@ -63,6 +75,7 @@ check_tested_thread_phase(tts, TT_PHASE_ATTACHED); check_tested_thread_structures(tts); } + // Terminate all threads and clear tts structures tested_threads_destroy(); return TEST_PASSED; @@ -72,27 +85,7 @@ * Test jthread_detach() */ int test_jthread_detach (void){ - tested_thread_sturct_t * tts; - jthread *thread; - hythread_t hythread; - - // Initialize tts structures and run all tested threads - tested_threads_run(default_run_for_test); - - // Make second attach to the same jthread. - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_RUNNING); - hythread = vm_jthread_get_tm_data(tts->java_thread); - thread = hythread_get_private_data(hythread); - tf_assert_same(jthread_detach(tts->java_thread), TM_ERROR_NONE); - tf_assert_null(vm_jthread_get_tm_data(tts->java_thread)); - //tf_assert_null(hythread_get_private_data(hythread)); - } - - // Terminate all threads and clear tts structures - tested_threads_destroy(); - return TEST_PASSED; + return test_jthread_attach(); } /* @@ -110,7 +103,7 @@ while(next_tested_thread(&tts)){ check_tested_thread_phase(tts, TT_PHASE_RUNNING); check_tested_thread_structures(tts); - tf_assert(tested_thread_is_running(tts)); + tested_thread_wait_running(tts); } // Terminate all tested threads and clear tts structures tested_threads_destroy(); @@ -121,23 +114,15 @@ /* * Test hythread_create_with_function(...) */ -void JNICALL jvmti_start_proc(jvmtiEnv *jvmti_env, JNIEnv *jni_env, void *arg){ +void JNICALL jvmti_start_proc(jvmtiEnv *jvmti_env, JNIEnv *jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t * ) args; - if (tts->jvmti_start_proc_arg != arg){ - tts->phase = TT_PHASE_ERROR; - return; - } tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_hythread_create_with_function(void) { @@ -146,14 +131,14 @@ void * args = &args; // Initialize tts structures and run all tested threads - tested_threads_run_with_jvmti_start_proc(jvmti_start_proc); + tested_threads_run(jvmti_start_proc); // Test that all threads are running and have associated structures valid reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ check_tested_thread_phase(tts, TT_PHASE_RUNNING); check_tested_thread_structures(tts); - tf_assert(tested_thread_is_running(tts)); + tested_thread_wait_running(tts); } // Terminate all threads and clear tts structures tested_threads_destroy(); @@ -164,9 +149,9 @@ /* * Test jthread_join() */ -void JNICALL run_for_test_jthread_join(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_join(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tested_thread_sturct_t * prev_tts = tts; IDATA status; @@ -174,20 +159,17 @@ if (prev_tts == NULL){ // its the first tested thread tts->phase = TT_PHASE_RUNNING; - - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - tts->phase = TT_PHASE_DEAD; - break; - } - } + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); + tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } else { // wait until previous thread ends tts->phase = TT_PHASE_WAITING_ON_JOIN; + tested_thread_started(tts); status = jthread_join(prev_tts->java_thread); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } } @@ -210,11 +192,10 @@ // make the first thread terminated and test that all threads are terminated reset_tested_thread_iterator(&tts); next_tested_thread(&tts); - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_DEAD); - jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0); + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_DEAD); + tested_thread_wait_ended(tts); } // Terminate all threads (not needed here) and clear tts structures @@ -226,24 +207,18 @@ /* * Test jthread_timed_join() */ -void JNICALL run_for_test_jthread_timed_join(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_timed_join(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tested_thread_sturct_t * prev_tts = tts; IDATA status; prev_tested_thread(&prev_tts); tts->phase = TT_PHASE_RUNNING; + tested_thread_started(tts); if (prev_tts == NULL){ - // its the first tested thread - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - tts->phase = TT_PHASE_DEAD; - break; - } - } + tested_thread_wait_for_stop_request(tts); + tts->phase = TT_PHASE_DEAD; } else { // wait until timeout or previous thread ends status = jthread_timed_join(prev_tts->java_thread, timed_join_wait_time, 0); @@ -257,6 +232,7 @@ //tts->phase = (status == TM_ERROR_TIMEOUT ? TT_PHASE_DEAD : TT_PHASE_ERROR); } } + tested_thread_ended(tts); } int test_jthread_timed_join(void) { @@ -293,8 +269,8 @@ // make the first thread terminated and test that all threads are terminated reset_tested_thread_iterator(&tts); next_tested_thread(&tts); - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_DEAD); + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0); while(next_tested_thread(&tts)){ check_tested_thread_phase(tts, TT_PHASE_DEAD); @@ -309,29 +285,30 @@ /* * Test jthread_exception_stop() */ -void JNICALL run_for_test_jthread_exception_stop(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_exception_stop(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tts->phase = TT_PHASE_RUNNING; - while(1){ + tested_thread_started(tts); + while(tested_thread_wait_for_stop_request_timed(tts, CLICK_TIME_MSEC) == TM_ERROR_TIMEOUT){ hythread_safe_point(); - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } } tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_exception_stop (void){ tested_thread_sturct_t * tts; - jobject excn = new_jobject(); + jobject excn; hythread_t hythread; jvmti_thread_t jvmti_thread; + JNIEnv * jni_env; + jni_env = jthread_get_JNI_env(jthread_self()); + excn = new_jobject_thread_death(jni_env); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_exception_stop); @@ -391,15 +368,18 @@ /* * Test jthread_sleep(...) */ -void JNICALL run_for_test_jthread_sleep(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_sleep(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_SLEEPING; + tested_thread_started(tts); status = jthread_sleep(1000000, 0); tts->phase = (status == TM_ERROR_INTERRUPT ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } + int test_jthread_sleep(void) { tested_thread_sturct_t *tts; @@ -410,17 +390,12 @@ // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_sleep); - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_SLEEPING); - } for (i = 0; i <= MAX_TESTED_THREAD_NUMBER; i++){ sleeping_nmb = 0; sleeping_tts = NULL; reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_SLEEPING){ sleeping_nmb++; sleeping_tts = tts; @@ -428,12 +403,12 @@ check_tested_thread_phase(tts, TT_PHASE_DEAD); } } - if (MAX_TESTED_THREAD_NUMBER - sleeping_nmb - i != 0){ + if (MAX_TESTED_THREAD_NUMBER - i != sleeping_nmb){ tf_fail("Wrong number of sleeping threads"); } if (sleeping_nmb > 0){ tf_assert_same(jthread_interrupt(sleeping_tts->java_thread), TM_ERROR_NONE); - check_tested_thread_phase(sleeping_tts, TT_PHASE_DEAD); + tested_thread_wait_ended(sleeping_tts); } } @@ -448,33 +423,27 @@ */ int test_jthread_get_JNI_env(void) { - tested_thread_sturct_t *tts; - tf_assert(jthread_get_JNI_env(jthread_self()) != 0); - return TEST_PASSED; } /* * Test hythread_yield() */ -void JNICALL run_for_test_hythread_yield(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_hythread_yield(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; - /* - IDATA status; - tts->phase = TT_PHASE_RUNNING; - */ + tts->phase = TT_PHASE_RUNNING; + tested_thread_started(tts); - while(1){ - tts->clicks++; + while(tested_thread_wait_for_stop_request_timed(tts, CLICK_TIME_MSEC) == TM_ERROR_TIMEOUT){ hythread_yield(); - if (tts->stop) { - break; - } } + tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); + /* tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); */ @@ -488,8 +457,8 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_DEAD); + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); } // Terminate all threads (not needed here) and clear tts structures @@ -499,14 +468,14 @@ } TEST_LIST_START - //TEST(test_jthread_attach) - //TEST(test_jthread_detach) + TEST(test_jthread_attach) + TEST(test_jthread_detach) TEST(test_hythread_create) TEST(test_hythread_create_with_function) TEST(test_jthread_get_JNI_env) TEST(test_jthread_join) - //TEST(test_jthread_timed_join) - //TEST(test_jthread_exception_stop) + TEST(test_jthread_timed_join) + TEST(test_jthread_exception_stop) //TEST(test_jthread_stop) TEST(test_jthread_sleep) TEST(test_hythread_yield) Index: trunk/vm/tests/unit/thread/test_java_identify.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_identify.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_identify.c (working copy) @@ -26,23 +26,15 @@ /* * Test jthread_self(...) */ -void JNICALL run_for_test_jthread_self(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_self(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tts->phase = TT_PHASE_RUNNING; - while(1){ - if (jthread_self()->object != tts->java_thread->object){ - tts->phase = TT_PHASE_ERROR; - return; - } - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); + tts->phase = jthread_self()->object == tts->java_thread->object ? TT_PHASE_DEAD : TT_PHASE_ERROR; + tested_thread_ended(tts); } int test_jthread_self(void) { @@ -54,7 +46,8 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tts->stop = 1; + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); } // Terminate all threads (not needed here) and clear tts structures Index: trunk/vm/tests/unit/thread/test_java_interrupt.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_interrupt.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_interrupt.c (working copy) @@ -23,27 +23,17 @@ /* * Test jthread_interrupt(...) */ -void JNICALL run_for_test_jthread_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (jthread_is_interrupted(jthread_self())) { - break; - } - } - tts->phase = TT_PHASE_INTERRUPTED; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); + tts->phase = jthread_is_interrupted(jthread_self()) ? TT_PHASE_INTERRUPTED : TT_PHASE_ERROR; + tested_thread_ended(tts); + tested_thread_wait_for_stop_request(tts); + tested_thread_ended(tts); } int test_jthread_interrupt(void){ @@ -61,6 +51,9 @@ tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); + check_tested_thread_phase(tts, TT_PHASE_INTERRUPTED); tf_assert_same(jthread_is_interrupted(tts->java_thread), 1); tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); @@ -73,113 +66,14 @@ return TEST_PASSED; } -/* - * Test jthread_is_interrupted(...) - */ -void JNICALL run_for_test_jthread_is_interrupted(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ - - tested_thread_sturct_t * tts = current_thread_tts; - - tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (jthread_is_interrupted(jthread_self())) { - break; - } - } - tts->phase = TT_PHASE_INTERRUPTED; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; -} int test_jthread_is_interrupted(void){ - - tested_thread_sturct_t *tts; - - // Initialize tts structures and run all tested threads - tested_threads_run(run_for_test_jthread_is_interrupted); - - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_NONE); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - - tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); - - check_tested_thread_phase(tts, TT_PHASE_INTERRUPTED); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 1); - tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 1); - tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_INTERRUPT); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - } - // Terminate all threads and clear tts structures - tested_threads_destroy(); - - return TEST_PASSED; + return test_jthread_interrupt(); } -/* - * Test jthread_clear_interrupted(...) - */ -void JNICALL run_for_test_jthread_clear_interrupted(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ - - tested_thread_sturct_t * tts = current_thread_tts; - - tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (jthread_is_interrupted(jthread_self())) { - break; - } - } - tts->phase = TT_PHASE_INTERRUPTED; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; +int test_jthread_clear_interrupted(void){ + return test_jthread_interrupt(); } -int test_jthread_clear_interrupted(void){ - - tested_thread_sturct_t *tts; - - // Initialize tts structures and run all tested threads - tested_threads_run(run_for_test_jthread_clear_interrupted); - - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_NONE); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - - tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); - - check_tested_thread_phase(tts, TT_PHASE_INTERRUPTED); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 1); - tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 1); - tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_INTERRUPT); - tf_assert_same(jthread_is_interrupted(tts->java_thread), 0); - } - // Terminate all threads and clear tts structures - tested_threads_destroy(); - - return TEST_PASSED; -} - TEST_LIST_START TEST(test_jthread_interrupt) TEST(test_jthread_is_interrupted) Index: trunk/vm/tests/unit/thread/test_java_monitors.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_monitors.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_monitors.c (working copy) @@ -21,6 +21,8 @@ #include #include +hysem_t mon_enter; + int helper_jthread_monitor_enter_exit(void); int helper_jthread_monitor_wait_notify(void); @@ -37,13 +39,14 @@ /* * Test jthread_monitor_try_enter() */ -void JNICALL run_for_test_jthread_monitor_try_enter(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_try_enter(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_try_enter(monitor); while (status == TM_ERROR_EBUSY){ status = jthread_monitor_try_enter(monitor); @@ -51,16 +54,12 @@ } // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_try_enter(void) { @@ -70,6 +69,7 @@ int i; int waiting_on_monitor_nmb; + hysem_create(&mon_enter, 0, 1); // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_try_enter); @@ -78,9 +78,10 @@ waiting_on_monitor_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -89,11 +90,11 @@ } } tf_assert(critical_tts); // thread in critical section found - if (MAX_TESTED_THREAD_NUMBER - waiting_on_monitor_nmb - i != 1){ + if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_monitor_nmb + 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; - check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); } // Terminate all threads and clear tts structures tested_threads_destroy(); @@ -114,9 +115,9 @@ /* * Test jthread_monitor_notify_all(...) */ -void JNICALL run_for_test_jthread_monitor_notify_all(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_notify_all(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -124,22 +125,21 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } // Begin critical section tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_wait(monitor); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_notify_all(void) { @@ -150,6 +150,8 @@ int i; int waiting_on_wait_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_notify_all); @@ -167,9 +169,10 @@ waiting_on_wait_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -178,11 +181,11 @@ } } tf_assert(critical_tts); // thread in critical section found - if (MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i != 1){ + if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_wait_nmb + 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; - check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); } // Terminate all threads and clear tts structures tested_threads_destroy(); @@ -193,9 +196,9 @@ /* * Test jthread_monitor_wait() */ -void JNICALL run_for_test_jthread_monitor_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -203,17 +206,17 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_wait(monitor); - if (status != TM_ERROR_NONE){ - tts->phase = TT_PHASE_ERROR; - return; - } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_wait (void){ @@ -221,6 +224,8 @@ tested_thread_sturct_t *tts; jobject monitor; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_wait); @@ -235,6 +240,7 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -246,9 +252,9 @@ /* * Test jthread_monitor_wait_interrupt() */ -void JNICALL run_for_test_jthread_monitor_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -256,17 +262,22 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_wait(monitor); - if (status != TM_ERROR_INTERRUPT){ + if (status != TM_ERROR_INTERRUPT) { tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_wait_interrupt(void){ @@ -276,6 +287,8 @@ int i; int waiting_on_wait_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_wait_interrupt); @@ -290,7 +303,6 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_WAITING_ON_WAIT){ waiting_tts = tts; waiting_on_wait_nmb++; @@ -298,9 +310,10 @@ check_tested_thread_phase(tts, TT_PHASE_DEAD); } } - tf_assert_same(MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i, 0); + tf_assert_same(MAX_TESTED_THREAD_NUMBER - i, waiting_on_wait_nmb); if (waiting_tts){ tf_assert_same(jthread_interrupt(waiting_tts->java_thread), TM_ERROR_NONE); + tested_thread_wait_ended(waiting_tts); check_tested_thread_phase(waiting_tts, TT_PHASE_DEAD); } } @@ -313,9 +326,9 @@ /* * Test jthread_monitor_timed_wait() */ -void JNICALL run_for_test_jthread_monitor_timed_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_timed_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -323,17 +336,22 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } tts->phase = TT_PHASE_WAITING_ON_WAIT; - status = jthread_monitor_timed_wait(monitor, 10 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER,0); + tested_thread_started(tts); + status = jthread_monitor_timed_wait(monitor, 10 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_timed_wait(void) { @@ -341,6 +359,8 @@ tested_thread_sturct_t *tts; jobject monitor; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_timed_wait); @@ -355,6 +375,7 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -366,10 +387,10 @@ /* * Test jthread_monitor_timed_wait() */ -void JNICALL run_for_test_jthread_monitor_timed_wait_timeout(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_timed_wait_timeout(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -377,17 +398,22 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_timed_wait(monitor, 10 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0); if (status != TM_ERROR_TIMEOUT){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_timed_wait_timeout(void) { @@ -395,6 +421,8 @@ tested_thread_sturct_t *tts; jobject monitor; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_timed_wait_timeout); @@ -409,6 +437,7 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ + tested_thread_wait_dead(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -420,9 +449,9 @@ /* * Test jthread_monitor_timed_wait() */ -void JNICALL run_for_test_jthread_monitor_timed_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_monitor_timed_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -430,17 +459,22 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_timed_wait(monitor, 100 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0); if (status != TM_ERROR_INTERRUPT){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_monitor_timed_wait_interrupt(void) { @@ -450,8 +484,8 @@ int i; int waiting_on_wait_nmb; - log_info("!!!!!!!!!!!!!! CRASHES"); - tf_assert(0); + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_monitor_timed_wait_interrupt); @@ -466,7 +500,6 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_WAITING_ON_WAIT){ waiting_tts = tts; waiting_on_wait_nmb++; @@ -474,11 +507,13 @@ check_tested_thread_phase(waiting_tts, TT_PHASE_DEAD); } } - tf_assert_same(MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i, 0); + tf_assert_same(MAX_TESTED_THREAD_NUMBER - i, waiting_on_wait_nmb); if (waiting_tts){ tf_assert_same(jthread_interrupt(waiting_tts->java_thread), TM_ERROR_NONE); + tested_thread_wait_ended(waiting_tts); + check_tested_thread_phase(waiting_tts, TT_PHASE_DEAD); } - check_tested_thread_phase(waiting_tts, TT_PHASE_DEAD); + } // Terminate all threads and clear tts structures tested_threads_destroy(); @@ -497,27 +532,24 @@ //?????????????????????????????? jthread_monitor_init and not init //?????????????????????????????? jthread_monitor_exit without enter -void JNICALL run_for_helper_jthread_monitor_enter_exit(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_jthread_monitor_enter_exit(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_jthread_monitor_enter_exit(void) { @@ -527,6 +559,8 @@ int i; int waiting_on_monitor_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_helper_jthread_monitor_enter_exit); @@ -534,9 +568,10 @@ waiting_on_monitor_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -545,10 +580,11 @@ } } tf_assert(critical_tts); // thread in critical section found - if (MAX_TESTED_THREAD_NUMBER - waiting_on_monitor_nmb - i != 1){ + if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_monitor_nmb + 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -561,9 +597,9 @@ * Test jthread_monitor_wait(...) * Test jthread_monitor_notify(...) */ -void JNICALL run_for_helper_jthread_monitor_wait_notify(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_jthread_monitor_wait_notify(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; @@ -571,22 +607,21 @@ status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_started(tts); + tested_thread_ended(tts); return; } // Begin critical section tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_monitor_wait(monitor); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_jthread_monitor_wait_notify(void) { @@ -597,6 +632,8 @@ int i; int waiting_on_wait_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_helper_jthread_monitor_wait_notify); @@ -613,13 +650,12 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running tf_assert(tts->phase != TT_PHASE_IN_CRITICAL_SECTON); } tf_assert_same(jthread_monitor_notify(monitor), TM_ERROR_NONE); + hysem_wait(mon_enter); reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -628,10 +664,11 @@ } } tf_assert(critical_tts); // thread in critical section found - if (MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i != 1){ + if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_wait_nmb + 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures Index: trunk/vm/tests/unit/thread/test_java_park.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_park.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_park.c (working copy) @@ -24,22 +24,18 @@ * Test jthread_park(...) * Test jthread_unpark(...) */ -void JNICALL run_for_test_jthread_park_unpark(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_park_unpark(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_PARKED; + tested_thread_started(tts); status = jthread_park(); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_RUNNING : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_wait_for_stop_request(tts); tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_park_unpark(void) { @@ -76,6 +72,7 @@ } if (parked_nmb > 0){ tf_assert_same(jthread_unpark(parked_tts->java_thread), TM_ERROR_NONE); + tested_thread_wait_running(parked_tts); check_tested_thread_phase(parked_tts, TT_PHASE_RUNNING); } } @@ -88,22 +85,18 @@ /* * Test jthread_park(...) */ -void JNICALL run_for_test_jthread_park_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_park_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_PARKED; + tested_thread_started(tts); status = jthread_park(); tts->phase = (status == TM_ERROR_INTERRUPT ? TT_PHASE_RUNNING : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_wait_for_stop_request(tts); tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_park_interrupt(void) { @@ -139,6 +132,7 @@ } if (parked_nmb > 0){ tf_assert_same(jthread_interrupt(parked_tts->java_thread), TM_ERROR_NONE); + tested_thread_wait_running(parked_tts); check_tested_thread_phase(parked_tts, TT_PHASE_RUNNING); } } @@ -151,22 +145,18 @@ /* * Test jthread_timed_park(...) */ -void JNICALL run_for_test_jthread_timed_park(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_timed_park(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_PARKED; + tested_thread_started(tts); status = jthread_timed_park(50, 0); tts->phase = (status == TM_ERROR_TIMEOUT ? TT_PHASE_RUNNING : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_wait_for_stop_request(tts); tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_timed_park(void) { @@ -178,6 +168,7 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ + tested_thread_wait_running(tts); check_tested_thread_phase(tts, TT_PHASE_RUNNING); } Index: trunk/vm/tests/unit/thread/test_java_suspend.c =================================================================== --- trunk/vm/tests/unit/thread/test_java_suspend.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_java_suspend.c (working copy) @@ -25,73 +25,59 @@ * Test jthread_suspend(...) * Test jthread_resume(...) */ -void JNICALL run_for_test_jthread_suspend_resume(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_suspend_resume(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; + IDATA status; tts->phase = TT_PHASE_RUNNING; - while(1){ + tested_thread_started(tts); + do { hythread_safe_point(); - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; + status = tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME); + hythread_suspend_disable(); + hythread_suspend_enable(); + } while (status == TM_ERROR_TIMEOUT); + tts->phase = status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR; + tested_thread_ended(tts); } int test_jthread_suspend_resume(void) { tested_thread_sturct_t *tts; tested_thread_sturct_t *switch_tts; - int i; - int suspended_nmb; // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_suspend_resume); - for (i = 0; i <= MAX_TESTED_THREAD_NUMBER; i++){ + switch_tts = get_tts(0); - suspended_nmb = 0; - switch_tts = NULL; + reset_tested_thread_iterator(&tts); + while(next_tested_thread(&tts)){ + tested_thread_wait_running(tts); + } - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ + tf_assert_same((jthread_suspend(switch_tts->java_thread)), TM_ERROR_NONE); + + reset_tested_thread_iterator(&tts); + while(next_tested_thread(&tts)){ + tested_thread_send_stop_request(tts); + } + + reset_tested_thread_iterator(&tts); + while(next_tested_thread(&tts)){ + if (tts != switch_tts) { + tested_thread_wait_ended(tts); + check_tested_thread_phase(tts, TT_PHASE_DEAD); + } else { check_tested_thread_phase(tts, TT_PHASE_RUNNING); - if (tested_thread_is_running(tts)){ - switch_tts = tts; - } else { - suspended_nmb++; - } } - if (suspended_nmb != i){ - tf_fail("Wrong number of suspended threads"); - } - if (switch_tts != NULL){ - tf_assert_same(jthread_suspend(switch_tts->java_thread), TM_ERROR_NONE); - } } - for (i = 0; i <= MAX_TESTED_THREAD_NUMBER; i++){ - suspended_nmb = 0; - switch_tts = NULL; + tf_assert_same(jthread_resume(switch_tts->java_thread), TM_ERROR_NONE); + tested_thread_wait_ended(switch_tts); + check_tested_thread_phase(switch_tts, TT_PHASE_DEAD); - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_RUNNING); - if (!tested_thread_is_running(tts)){ - suspended_nmb++; - switch_tts = tts; - } - } - if (suspended_nmb != MAX_TESTED_THREAD_NUMBER - i){ - tf_fail("Wrong number of suspended threads"); - } - if (switch_tts != NULL){ - tf_assert_same(jthread_resume(switch_tts->java_thread), TM_ERROR_NONE); - } - } // Terminate all threads and clear tts structures tested_threads_destroy(); @@ -101,7 +87,6 @@ * Test jthread_suspend_all(...) * Test jthread_resume_all(...) */ - int test_jthread_suspend_all_resume_all(void) { tested_thread_sturct_t * tts; @@ -115,29 +100,31 @@ // Test that all threads are running reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ + tested_thread_wait_running(tts); all_threads[i] = tts->java_thread; results[i] = (jvmtiError)(TM_ERROR_NONE + 1); i++; - tf_assert(tested_thread_is_running(tts)); } tf_assert_same(jthread_suspend_all(results, MAX_TESTED_THREAD_NUMBER, all_threads), TM_ERROR_NONE); // Test that all threads are suspended + reset_tested_thread_iterator(&tts); + while(next_tested_thread(&tts)){ + tested_thread_send_stop_request(tts); + } i = 0; reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tf_assert(!tested_thread_is_running(tts)); + check_tested_thread_phase(tts, TT_PHASE_RUNNING); tf_assert_same(results[i], TM_ERROR_NONE); results[i] = (jvmtiError)(TM_ERROR_NONE + 1); i++; } tf_assert_same(jthread_resume_all(results, MAX_TESTED_THREAD_NUMBER, all_threads), TM_ERROR_NONE); // Test that all threads are running - i = 0; reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tf_assert(tested_thread_is_running(tts)); - tf_assert_same(results[i], TM_ERROR_NONE); - i++; + tested_thread_wait_ended(tts); + check_tested_thread_phase(tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures tested_threads_destroy(); Index: trunk/vm/tests/unit/thread/test_native_basic.c =================================================================== --- trunk/vm/tests/unit/thread/test_native_basic.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_native_basic.c (working copy) @@ -44,19 +44,19 @@ apr_pool_create(&pool, NULL); - args = (void**) apr_palloc(pool, sizeof(void *) *3); + args = (void**) apr_palloc(pool, sizeof(void *) *2); hythread_group_create((hythread_group_t *)&args[0]); args[1] = apr_palloc(pool, sizeof(jthread_threadattr_t)); ((jthread_threadattr_t *)args[1])->stacksize = 1024; ((jthread_threadattr_t *)args[1])->priority = 1; - args[2] = pool; hythread_create_with_group(&thread, args[0], 1024, 1, 0, start_proc, args); - //hythread_join(thread); - return 0; + hythread_join(thread); + // TODO: should check that created thread finished without errors. + return TEST_PASSED; } hylatch_t start; @@ -78,7 +78,7 @@ hythread_create_with_group(&thread, group, 0, 0, 0, start_proc_empty, NULL); } - // Wait util all thread has started. + // Wait util all threads have started. hylatch_wait(start); iterator = hythread_iterator_create(group); // Notify all threads @@ -114,7 +114,7 @@ hythread_create(&thread, 0, 0, 0, start_proc_empty, NULL); } - // Wait util all thread has started. + // Wait util all threads have started. hylatch_wait(start); iterator = hythread_iterator_create(NULL); // Notify all threads @@ -153,7 +153,7 @@ while(i--) { apr_pool_create(&pool, NULL); - args = (void**) apr_palloc(pool, sizeof(void *) *3); + args = (void**) apr_palloc(pool, sizeof(void *) *2); args[0] = group; @@ -161,8 +161,6 @@ ((jthread_threadattr_t *)args[1])->stacksize = 1024; ((jthread_threadattr_t *)args[1])->priority = 1; - args[2] = pool; - thread = NULL; hythread_create_with_group(&thread, group, 1024, 1, 0, start_proc, args); @@ -193,8 +191,6 @@ void** attrs = (void **)args; tf_assert_same(hythread_self()->priority, ((jthread_threadattr_t *)attrs[1])->priority); tf_assert_same(hythread_self()->group, attrs[0]); - hythread_sleep(1000); - apr_pool_destroy((apr_pool_t *)attrs[2]); return 0; } Index: trunk/vm/tests/unit/thread/test_native_thin_monitor.c =================================================================== --- trunk/vm/tests/unit/thread/test_native_thin_monitor.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_native_thin_monitor.c (working copy) @@ -121,7 +121,6 @@ int test_hythread_thin_monitor_enter_contended(void){ apr_pool_t *pool; void **args; - jthread_threadattr_t *attr; hythread_t thread = NULL; hythread_thin_monitor_t lockword_ptr; IDATA status; Index: trunk/vm/tests/unit/thread/test_ti_instrum.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_instrum.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_instrum.c (working copy) @@ -20,25 +20,10 @@ #include "thread_unit_test_utils.h" #include #include +#include -hysem_t start; +hysem_t mon_enter; -void JNICALL run_for_test_jthread_get_all_threads(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg) { - - tested_thread_sturct_t * tts = current_thread_tts; - - tts->phase = TT_PHASE_RUNNING; - hysem_set(start, 1); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - tts->phase = TT_PHASE_DEAD; -} - /* * Test jthread_get_all_threads(...) */ @@ -54,9 +39,9 @@ int i; jni_env = jthread_get_JNI_env(jthread_self()); - hysem_create(&start, 0, 1); - sleep_a_click(); + // TODO: unsafe .... need to find another way of synchronization + hythread_sleep(1000); jthread_get_thread_count(&initial_thread_count); jthread_get_all_threads(&threads, &initial_all_threads_count); @@ -72,9 +57,9 @@ i = 0; reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - current_thread_tts = tts; - tf_assert_same(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs, run_for_test_jthread_get_all_threads, NULL), TM_ERROR_NONE); - hysem_wait(start); + tf_assert_same(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs, default_run_for_test, tts), TM_ERROR_NONE); + tested_thread_wait_started(tts); + tts->native_thread = (hythread_t) vm_jthread_get_tm_data(tts->java_thread); check_tested_thread_phase(tts, TT_PHASE_RUNNING); tf_assert_same(jthread_get_thread_count(&thread_count), TM_ERROR_NONE); tf_assert_same(jthread_get_all_threads(&threads, &all_threads_count), TM_ERROR_NONE); @@ -101,27 +86,24 @@ /* * Test get_blocked_count(...) */ -void JNICALL run_for_test_jthread_get_blocked_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_blocked_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_blocked_count(void) { @@ -131,6 +113,8 @@ int i; int waiting_on_monitor_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_get_blocked_count); @@ -139,18 +123,23 @@ waiting_on_monitor_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ + tf_assert(critical_tts == NULL); critical_tts = tts; } } + // TODO: unsafe .... need to find another way of synchronization + hythread_sleep(1000); tf_assert_same(jthread_get_blocked_count(&waiting_on_monitor_nmb), TM_ERROR_NONE); - if (MAX_TESTED_THREAD_NUMBER - waiting_on_monitor_nmb - i != 1){ + if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_monitor_nmb + 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -162,29 +151,25 @@ /* * Test jthread_get_deadlocked_threads(...) */ -void JNICALL run_for_test_jthread_get_deadlocked_threads(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_deadlocked_threads(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; - IDATA status; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; + IDATA status = TM_ERROR_NONE; if (tts->my_index < 2){ status = jthread_monitor_enter(tts->monitor); } tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); if (tts->my_index == 0){ status = jthread_monitor_enter(get_tts(1)->monitor); } else if (tts->my_index == 1){ status = jthread_monitor_enter(get_tts(0)->monitor); } - tts->phase = TT_PHASE_DEAD; + tts->phase = status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR; + tested_thread_ended(tts); } int test_jthread_get_deadlocked_threads(void) { @@ -212,54 +197,53 @@ &dead_list, &dead_list_count), TM_ERROR_NONE); tf_assert_same(dead_list_count, 0); - reset_tested_thread_iterator(&tts); - next_tested_thread(&tts); - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_ANY); - next_tested_thread(&tts); - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_ANY); + tested_thread_send_stop_request(get_tts(0)); + tested_thread_send_stop_request(get_tts(1)); + + // TODO: unsafe .... need to find another way of synchronization + hythread_sleep(5000); tf_assert_same(jthread_get_deadlocked_threads(thread_list, MAX_TESTED_THREAD_NUMBER, &dead_list, &dead_list_count), TM_ERROR_NONE); tf_assert_same(dead_list_count, 2); + tf_assert_same(jthread_monitor_exit(get_tts(0)->java_thread), TM_ERROR_NONE); + tf_assert_same(jthread_monitor_exit(get_tts(1)->java_thread), TM_ERROR_NONE); + + // Terminate all threads and clear tts structures + tested_threads_destroy(); + return TEST_PASSED; } /* * Test get_wated_count(...) */ -void JNICALL run_for_test_jthread_get_waited_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_waited_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_started(tts); status = jthread_monitor_enter(monitor); + tested_thread_wait_for_stop_request(tts); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_WAITING_ON_WAIT : TT_PHASE_ERROR); status = jthread_monitor_wait(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_waited_count(void) { - tested_thread_sturct_t *tts; - tested_thread_sturct_t *running_tts; int i; int waiting_nmb; jobject monitor; @@ -270,27 +254,17 @@ for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ waiting_nmb = 0; - running_tts = NULL; - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running - if (tts->phase == TT_PHASE_RUNNING){ - running_tts = tts; - } - } tf_assert_same(jthread_get_waited_count(&waiting_nmb), TM_ERROR_NONE); if (waiting_nmb != i){ tf_fail("Wrong number waiting on monitor threads"); } - if (running_tts){ - running_tts->stop = 1; - } - check_tested_thread_phase(running_tts, TT_PHASE_WAITING_ON_WAIT); + tested_thread_send_stop_request(get_tts(i)); + // TODO: unsafe .... need to find another way of synchronization + hythread_sleep(1000); + check_tested_thread_phase(get_tts(i), TT_PHASE_WAITING_ON_WAIT); } - reset_tested_thread_iterator(&tts); - next_tested_thread(&tts); - monitor = tts->monitor; + monitor = get_tts(0)->monitor; tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE); tf_assert_same(jthread_monitor_notify_all(monitor), TM_ERROR_NONE); tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE); Index: trunk/vm/tests/unit/thread/test_ti_monitor_info.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_monitor_info.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_monitor_info.c (working copy) @@ -23,7 +23,7 @@ #include #include -hylatch_t mon_enter; +hysem_t mon_enter; int ti_is_enabled() { return 1; @@ -32,28 +32,23 @@ /* * Test jthread_get_contended_monitor(...) */ -void JNICALL run_for_test_jthread_get_contended_monitor(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_contended_monitor(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - hylatch_count_down(mon_enter); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - hylatch_set(mon_enter, 1); + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); // End critical section status = jthread_monitor_exit(monitor); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_contended_monitor(void) { @@ -63,18 +58,18 @@ jobject contended_monitor; int i; - hylatch_create(&mon_enter, 1); + hysem_create(&mon_enter, 0, 1); // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_get_contended_monitor); - reset_tested_thread_iterator(&tts); for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ critical_tts = NULL; + + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running - hylatch_wait(mon_enter); tf_assert_same(jthread_get_contended_monitor(tts->java_thread, &contended_monitor), TM_ERROR_NONE); if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert_null(contended_monitor); @@ -86,7 +81,8 @@ //tf_assert(vm_objects_are_equal(contended_monitor, tts->monitor)); } } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -98,26 +94,23 @@ /* * Test jthread_holds_lock(...) */ -void JNICALL run_for_test_jthread_holds_lock(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_holds_lock(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_holds_lock(void) { @@ -127,15 +120,20 @@ int blocked_count; int i; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_holds_lock); + for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ blocked_count = 0; critical_tts = NULL; + + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(jthread_holds_lock(tts->java_thread, tts->monitor) > 0); tf_assert_null(critical_tts); @@ -150,9 +148,9 @@ } tf_assert(critical_tts); // thread in critical section found tf_assert_same(blocked_count, MAX_TESTED_THREAD_NUMBER - i - 1); - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); - check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -164,26 +162,23 @@ /* * Test jthread_get_lock_owner(...) */ -void JNICALL run_for_test_jthread_get_lock_owner(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_lock_owner(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_lock_owner(void) { @@ -194,15 +189,21 @@ int blocked_count; int i; + hysem_create(&mon_enter, 0 , 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_get_lock_owner); for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ blocked_count = 0; + critical_tts = NULL; + + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ + tf_assert_null(critical_tts); critical_tts = tts; } else if (tts->phase == TT_PHASE_WAITING_ON_MONITOR){ blocked_count++; @@ -213,7 +214,8 @@ tf_assert_same(jthread_get_lock_owner(critical_tts->monitor, &lock_owner), TM_ERROR_NONE); tf_assert(lock_owner); tf_assert_same(critical_tts->java_thread->object, lock_owner->object); - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -225,29 +227,23 @@ /* * Test jthread_get_owned_monitors(...) */ -void JNICALL run_for_test_jthread_get_owned_monitors(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_owned_monitors(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); - // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - hylatch_count_down(mon_enter); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - hylatch_set(mon_enter, 1); + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_owned_monitors(void) { @@ -258,7 +254,7 @@ jint owned_monitors_count; jobject *owned_monitors = NULL; - hylatch_create(&mon_enter, 1); + hysem_create(&mon_enter, 0, 1); // Initialize tts structures and run all tested threads tested_threads_run(run_for_test_jthread_get_owned_monitors); @@ -266,14 +262,14 @@ for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running - hylatch_wait(mon_enter); tf_assert_same(jthread_get_owned_monitors (tts->java_thread, &owned_monitors_count, &owned_monitors), TM_ERROR_NONE); if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ - tf_assert(critical_tts == NULL); // error if two threads in critical section + tf_assert(critical_tts == NULL); critical_tts = tts; tf_assert_same(owned_monitors_count, 1); tf_assert_same(owned_monitors[0]->object, tts->monitor->object); @@ -281,9 +277,9 @@ tf_assert_same(owned_monitors_count, 0); } } - tf_assert(critical_tts); // thread in critical section found - critical_tts->stop = 1; - check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); + tf_assert(critical_tts); + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); } // Terminate all threads and clear tts structures tested_threads_destroy(); Index: trunk/vm/tests/unit/thread/test_ti_peak_count.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_peak_count.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_peak_count.c (working copy) @@ -44,27 +44,22 @@ return helper_get_reset_peak_count(); } -void JNICALL run_for_helper_get_reset_peak_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_get_reset_peak_count(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; - int i; int num = 0; status = jthread_reset_peak_thread_count(); tts->peak_count = 0; tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_RUNNING : TT_PHASE_ERROR); - while(1){ - for (i = 0; i < 1000; i++){ - num = num + 1; - } - if (tts->stop) { - break; - } - sleep_a_click(); + tested_thread_started(tts); + while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT) { + ++num; } status = jthread_get_peak_thread_count(&tts->peak_count); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_get_reset_peak_count(void) { @@ -76,7 +71,8 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tts->stop = 1; + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); printf("peak_count = %i \n", tts->peak_count); tf_assert(tts->peak_count > 0); Index: trunk/vm/tests/unit/thread/test_ti_raw_monitors.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_raw_monitors.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_raw_monitors.c (working copy) @@ -87,33 +87,31 @@ * ------------------------ HELPERS ----------------------- */ +hysem_t mon_enter; /* * Test jthread_raw_monitor_enter(...) * Test jthread_raw_monitor_exit(...) */ //?????????????????????????????? jthread_raw_monitor_init and not init //?????????????????????????????? jthread_raw_monitor_exit without enter -void JNICALL run_for_helper_jthread_raw_monitor_enter_exit(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_jthread_raw_monitor_enter_exit(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jrawMonitorID monitor = tts->raw_monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_raw_monitor_enter(monitor); // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_raw_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_jthread_raw_monitor_enter_exit(void) { @@ -123,6 +121,8 @@ int i; int waiting_on_monitor_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_helper_jthread_raw_monitor_enter_exit); @@ -131,9 +131,10 @@ waiting_on_monitor_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -145,7 +146,8 @@ if (MAX_TESTED_THREAD_NUMBER - waiting_on_monitor_nmb - i != 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -158,9 +160,9 @@ * Test jthread_raw_wait(...) * Test jthread_raw_notify(...) */ -void JNICALL run_for_helper_jthread_raw_wait_notify(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_jthread_raw_wait_notify(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jrawMonitorID monitor = tts->raw_monitor; IDATA status; int64 msec = 1000000; @@ -168,22 +170,20 @@ status = jthread_raw_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } // Begin critical section tts->phase = TT_PHASE_WAITING_ON_WAIT; + tested_thread_started(tts); status = jthread_raw_monitor_wait(monitor, msec); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_raw_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_jthread_raw_wait_notify(void) { @@ -191,10 +191,11 @@ tested_thread_sturct_t *tts; tested_thread_sturct_t *critical_tts; jrawMonitorID monitor; - int64 msec = 1000000; int i; int waiting_on_wait_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_helper_jthread_raw_wait_notify); @@ -210,13 +211,12 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running tf_assert(tts->phase != TT_PHASE_IN_CRITICAL_SECTON); } tf_assert_same(jthread_raw_monitor_notify(monitor), TM_ERROR_NONE); + hysem_wait(mon_enter); reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -228,7 +228,8 @@ if (MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i != 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -241,35 +242,7 @@ * Test jthread_raw_wait(...) * Test jthread_raw_notify_all(...) */ -void JNICALL run_for_helper_jthread_raw_wait_notify_all(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ - tested_thread_sturct_t * tts = current_thread_tts; - jrawMonitorID monitor = tts->raw_monitor; - int64 msec = 1000000; - IDATA status; - - tts->phase = TT_PHASE_WAITING_ON_MONITOR; - status = jthread_raw_monitor_enter(monitor); - if (status != TM_ERROR_NONE){ - tts->phase = TT_PHASE_ERROR; - return; - } - // Begin critical section - tts->phase = TT_PHASE_WAITING_ON_WAIT; - status = jthread_raw_monitor_wait(monitor, msec); - tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } - status = jthread_raw_monitor_exit(monitor); - // Exit critical section - tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); -} - int helper_jthread_raw_wait_notify_all(void) { tested_thread_sturct_t *tts; @@ -278,8 +251,10 @@ int i; int waiting_on_wait_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads - tested_threads_run(run_for_helper_jthread_raw_wait_notify_all); + tested_threads_run(run_for_helper_jthread_raw_wait_notify); reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ @@ -295,9 +270,10 @@ waiting_on_wait_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -309,7 +285,8 @@ if (MAX_TESTED_THREAD_NUMBER - waiting_on_wait_nmb - i != 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures @@ -318,13 +295,14 @@ return TEST_PASSED; } -void JNICALL run_for_helper_jthread_raw_monitor_try_enter(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_jthread_raw_monitor_try_enter(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jrawMonitorID monitor = tts->raw_monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_raw_monitor_try_enter(monitor); while (status == TM_ERROR_EBUSY){ status = jthread_raw_monitor_try_enter(monitor); @@ -332,16 +310,12 @@ } // Begin critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_IN_CRITICAL_SECTON : TT_PHASE_ERROR); - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + hysem_set(mon_enter, 1); + tested_thread_wait_for_stop_request(tts); status = jthread_raw_monitor_exit(monitor); // End critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int helper_jthread_raw_monitor_try_enter(void) { @@ -351,6 +325,8 @@ int i; int waiting_on_monitor_nmb; + hysem_create(&mon_enter, 0, 1); + // Initialize tts structures and run all tested threads tested_threads_run(run_for_helper_jthread_raw_monitor_try_enter); @@ -359,9 +335,10 @@ waiting_on_monitor_nmb = 0; critical_tts = NULL; + hysem_wait(mon_enter); + reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_ANY); // to make thread running if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ tf_assert(critical_tts == NULL); // error if two threads in critical section critical_tts = tts; @@ -373,7 +350,8 @@ if (MAX_TESTED_THREAD_NUMBER - waiting_on_monitor_nmb - i != 1){ tf_fail("Wrong number waiting on monitor threads"); } - critical_tts->stop = 1; + tested_thread_send_stop_request(critical_tts); + tested_thread_wait_ended(critical_tts); check_tested_thread_phase(critical_tts, TT_PHASE_DEAD); } // Terminate all threads and clear tts structures Index: trunk/vm/tests/unit/thread/test_ti_state.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_state.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_state.c (working copy) @@ -34,20 +34,18 @@ * jthread_clear_interrupted() ALIVE | RUNNABLE * DEAD */ -void JNICALL run_for_test_jthread_get_state_1(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_1(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; tts->phase = TT_PHASE_RUNNING; - while(1){ + tested_thread_started(tts); + while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){ hythread_safe_point(); - tts->clicks++; hythread_yield(); - if (tts->stop) { - break; - } } tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_get_state_1(void) { @@ -74,7 +72,7 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - check_tested_thread_phase(tts, TT_PHASE_RUNNING); + tested_thread_wait_running(tts); tf_assert_same(jthread_get_state(tts->java_thread, &state), TM_ERROR_NONE); ref_state = 0x5; if(tts->my_index == 0){ @@ -98,7 +96,8 @@ } //tf_assert_same(state, ref_state); - tts->stop = 1; + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); tf_assert_same(jthread_get_state(tts->java_thread, &state), TM_ERROR_NONE); ref_state = 0x2; @@ -116,16 +115,18 @@ /* * Test jthread_get_state(...) */ -void JNICALL run_for_test_jthread_get_state_2(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_2(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } // Begin critical section @@ -138,15 +139,12 @@ status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_RUNNING : TT_PHASE_ERROR); - while(1){ + while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){ hythread_safe_point(); - tts->clicks++; hythread_yield(); - if (tts->stop) { - break; - } } tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int test_jthread_get_state_2(void) { @@ -231,16 +229,18 @@ /* * Test jthread_get_state(...) */ -void JNICALL run_for_test_jthread_get_state_3(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_3(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } // Begin critical section @@ -248,11 +248,13 @@ status = jthread_monitor_timed_wait(monitor, 1000000, 100); if (status != TM_ERROR_INTERRUPT){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_state_3(void) { @@ -288,16 +290,18 @@ /* * Test jthread_get_state(...) */ -void JNICALL run_for_test_jthread_get_state_4(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_4(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; jobject monitor = tts->monitor; IDATA status; tts->phase = TT_PHASE_WAITING_ON_MONITOR; + tested_thread_started(tts); status = jthread_monitor_enter(monitor); if (status != TM_ERROR_NONE){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } // Begin critical section @@ -305,11 +309,13 @@ status = jthread_monitor_timed_wait(monitor, CLICK_TIME_MSEC, 0); if (status != TM_ERROR_TIMEOUT){ tts->phase = TT_PHASE_ERROR; + tested_thread_ended(tts); return; } status = jthread_monitor_exit(monitor); // Exit critical section tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_state_4(void) { @@ -342,14 +348,16 @@ /* * Test jthread_get_state(...) */ -void JNICALL run_for_test_jthread_get_state_5(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_5(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_SLEEPING; + tested_thread_started(tts); status = hythread_sleep(1000000); tts->phase = (status == TM_ERROR_INTERRUPT ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_state_5(void) { @@ -385,14 +393,16 @@ /* * Test jthread_get_state(...) */ -void JNICALL run_for_test_jthread_get_state_6(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_test_jthread_get_state_6(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; IDATA status; tts->phase = TT_PHASE_SLEEPING; + tested_thread_started(tts); status = hythread_sleep(CLICK_TIME_MSEC); tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR); + tested_thread_ended(tts); } int test_jthread_get_state_6(void) { Index: trunk/vm/tests/unit/thread/test_ti_timing.c =================================================================== --- trunk/vm/tests/unit/thread/test_ti_timing.c (revision 454602) +++ trunk/vm/tests/unit/thread/test_ti_timing.c (working copy) @@ -64,23 +64,18 @@ return helper_hythread_cpu_timing(); } -void JNICALL run_for_helper_hythread_cpu_timing(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg){ +void JNICALL run_for_helper_hythread_cpu_timing(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args){ - tested_thread_sturct_t * tts = current_thread_tts; - int i; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; int num = 0; tts->phase = TT_PHASE_RUNNING; - while(1){ - for (i = 0; i < 1000; i++){ - num = num + 1; - } - if (tts->stop) { - break; - } - sleep_a_click(); + tested_thread_started(tts); + while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT) { + ++num; } tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } int helper_hythread_cpu_timing(void) { @@ -100,7 +95,8 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - tts->stop = 1; + tested_thread_send_stop_request(tts); + tested_thread_wait_ended(tts); check_tested_thread_phase(tts, TT_PHASE_DEAD); tf_assert_same(jthread_get_thread_cpu_time(tts->java_thread, &cpu_time), TM_ERROR_NONE); @@ -110,6 +106,7 @@ tf_assert_same(jthread_get_thread_cpu_timer_info(&timer_info), TM_ERROR_NONE); tf_assert(user_cpu_time > 0); + /* printf("=================================================== %08x\n", cpu_time); printf("cpu_time = %i \n", cpu_time); printf("user_cpu_time = %i \n", user_cpu_time); @@ -122,6 +119,7 @@ printf("may_skip_forward = %i \n", timer_info.may_skip_forward); printf("may_skip_backward = %i \n", timer_info.may_skip_backward); printf("kind = %i \n", timer_info.kind); + */ } // Terminate all threads and clear tts structures Index: trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c =================================================================== --- trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c (revision 454602) +++ trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c (working copy) @@ -23,6 +23,7 @@ #include #include #include +#include #include "apr_time.h" @@ -30,10 +31,10 @@ * Utilities for thread manager unit tests */ -tested_thread_sturct_t * current_thread_tts; tested_thread_sturct_t dummy_tts_struct; tested_thread_sturct_t * dummy_tts = &dummy_tts_struct; tested_thread_sturct_t tested_threads[MAX_TESTED_THREAD_NUMBER]; +JavaVM * GLOBAL_VM = NULL; apr_pool_t *pool = NULL; @@ -41,7 +42,7 @@ apr_sleep(CLICK_TIME_MSEC * 1000); } -jthread new_jthread_jobject(JNIEnv * jni_env) { +jthread new_jobject_thread(JNIEnv * jni_env) { const char * name = ""; const char * sig = "()V"; jmethodID constructor = NULL; @@ -52,6 +53,17 @@ return (*jni_env)->NewObject(jni_env, thread_class, constructor); } +jobject new_jobject_thread_death(JNIEnv * jni_env) { + const char * name = ""; + const char * sig = "()V"; + jmethodID constructor = NULL; + jclass thread_death_class; + + thread_death_class = (*jni_env)->FindClass(jni_env, "java/lang/ThreadDeath"); + constructor = (*jni_env)->GetMethodID(jni_env, thread_death_class, name, sig); + return (*jni_env)->NewObject(jni_env, thread_death_class, constructor); +} + jthread new_jobject(){ apr_status_t status; @@ -78,7 +90,6 @@ void test_java_thread_setup(int argc, char *argv[]) { JavaVMInitArgs args; - JavaVM * java_vm; JNIEnv * jni_env; int i; @@ -93,8 +104,9 @@ log_debug("test_java_thread_init()"); + hythread_sleep(1000); apr_initialize(); - JNI_CreateJavaVM(&java_vm, &jni_env, &args); + JNI_CreateJavaVM(&GLOBAL_VM, &jni_env, &args); } void test_java_thread_teardown(void) { @@ -140,14 +152,15 @@ for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ tts = &tested_threads[i]; tts->my_index = i; - //tf_assert_null(tts->java_thread); - tts->java_thread = new_jthread_jobject(jni_env); - //tf_assert_null(tts->jni_env); + tts->java_thread = new_jobject_thread(jni_env); + tts->native_thread = NULL; //tts->attrs.priority = 5; tts->jvmti_start_proc_arg = &tts->jvmti_start_proc_arg; - tts->clicks = 0; + hysem_create(&tts->started, 0, 1); + hysem_create(&tts->running, 0, 1); + hysem_create(&tts->stop_request, 0, 1); + hysem_create(&tts->ended, 0, 1); tts->phase = TT_PHASE_NONE; - tts->stop = 0; if (mode == TTS_INIT_DIFFERENT_MONITORS){ monitor = new_jobject(); status = jthread_monitor_init(monitor); @@ -230,10 +243,9 @@ reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - current_thread_tts = tts; - tf_assert_same_v(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs, run_method_param, NULL), TM_ERROR_NONE); - check_tested_thread_phase(tts, TT_PHASE_ANY); - check_tested_thread_structures(tts); + tf_assert_same_v(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs, run_method_param, tts), TM_ERROR_NONE); + tested_thread_wait_started(tts); + tts->native_thread = (hythread_t) vm_jthread_get_tm_data(tts->java_thread); } } @@ -249,85 +261,88 @@ tested_threads_run_common(run_method_param); } -void tested_threads_run_with_jvmti_start_proc(jvmtiStartFunction jvmti_start_proc){ +void tested_os_threads_run(hythread_entrypoint_t run_method_param){ + tested_thread_sturct_t *tts; - JNIEnv * jni_env; + IDATA status; - jni_env = jthread_get_JNI_env(jthread_self()); - tested_threads_init(TTS_INIT_COMMON_MONITOR); reset_tested_thread_iterator(&tts); while(next_tested_thread(&tts)){ - current_thread_tts = tts; - tf_assert_same_v(jthread_create_with_function(jni_env, tts->java_thread, &tts->attrs, - jvmti_start_proc, tts->jvmti_start_proc_arg), TM_ERROR_NONE); - check_tested_thread_phase(tts, TT_PHASE_ANY); + // Create thread + status = hythread_create(&tts->native_thread, // new thread OS handle + 0, 5, 0, + run_method_param, // start proc + tts); + tf_assert_v(status == TM_ERROR_NONE); + tested_thread_wait_started(tts); } } -void tested_os_threads_run(apr_thread_start_t run_method_param){ +void tested_thread_started(tested_thread_sturct_t * tts) { + hysem_set(tts->started, 1); +} - tested_thread_sturct_t *tts; - apr_thread_t *apr_thread; - apr_threadattr_t *apr_attrs = NULL; - apr_status_t status; - apr_pool_t *pool; +void tested_thread_ended(tested_thread_sturct_t * tts) { + hysem_set(tts->ended, 1); +} - status = apr_pool_create(&pool, NULL); - tf_assert_v(status == APR_SUCCESS); - tested_threads_init(TTS_INIT_COMMON_MONITOR); - reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - current_thread_tts = tts; - apr_thread = NULL; - // Create APR thread - status = apr_thread_create( - &apr_thread, // new thread OS handle - apr_attrs, - run_method_param, // start proc - NULL, // start proc arg - pool - ); - tf_assert_v(status == APR_SUCCESS); - check_tested_thread_phase(tts, TT_PHASE_ANY); - } +void tested_thread_send_stop_request(tested_thread_sturct_t * tts) { + hysem_set(tts->stop_request, 1); } -int tested_threads_stop(){ +void tested_thread_wait_for_stop_request(tested_thread_sturct_t * tts) { + IDATA status; + do { + hysem_set(tts->running, 1); + status = hysem_wait_timed(tts->stop_request, SLEEP_TIME, 0); + } while (status == TM_ERROR_TIMEOUT); +} +IDATA tested_thread_wait_for_stop_request_timed(tested_thread_sturct_t * tts, I_64 sleep_time) { + hysem_set(tts->running, 1); + return hysem_wait_timed(tts->stop_request, sleep_time, 0); +} + +int tested_threads_stop() { + tested_thread_sturct_t *tts; reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - if (check_tested_thread_phase(tts, TT_PHASE_DEAD) != TEST_PASSED){ - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_DEAD); - //Sleep(1000); - } + while (next_tested_thread(&tts)) { + tested_thread_send_stop_request(tts); } + while (next_tested_thread(&tts)) { + tested_thread_wait_ended(tts); + } return TEST_PASSED; } -int tested_threads_destroy(){ +int tested_threads_destroy() { tested_thread_sturct_t *tts; reset_tested_thread_iterator(&tts); - while(next_tested_thread(&tts)){ - tts->stop = 1; - check_tested_thread_phase(tts, TT_PHASE_DEAD); + while (next_tested_thread(&tts)) { + tested_thread_send_stop_request(tts); } + reset_tested_thread_iterator(&tts); + while (next_tested_thread(&tts)) { + tested_thread_wait_dead(tts); + } + return TEST_PASSED; } -int check_tested_thread_structures(tested_thread_sturct_t *tts){ +int check_structure(tested_thread_sturct_t *tts){ + jthread java_thread = tts->java_thread; jvmti_thread_t jvmti_thread; hythread_t hythread; - hythread = vm_jthread_get_tm_data(java_thread); - tf_assert(hythread); + hythread = (hythread_t) vm_jthread_get_tm_data(java_thread); + tf_assert_same(hythread, tts->native_thread); jvmti_thread = hythread_get_private_data(hythread); tf_assert(jvmti_thread); /* @@ -339,41 +354,65 @@ //if(jvmti_thread->stop_exception != stop_exception){ // return TEST_FAILED; ???????????????????????????????????????????? //} + return TEST_PASSED; +} +int check_phase(tested_thread_sturct_t *tts, int phase) { + + tf_assert(tts->phase != TT_PHASE_ERROR); + if (phase == TT_PHASE_ANY) { + tf_assert(tts->phase != TT_PHASE_NONE); + } else { + tf_assert_same(tts->phase, phase); + } return TEST_PASSED; } -int check_tested_thread_phase(tested_thread_sturct_t *tts, int phase){ - +void tested_thread_wait_started(tested_thread_sturct_t *tts) { int i; - for (i = 0; i < MAX_CLICKS_TO_WAIT; i++){ - sleep_a_click(); // must be here to give tested thread to change phase - - tf_assert(tts->phase != TT_PHASE_ERROR); - if (phase == tts->phase){ - return 0; - } - if (phase == TT_PHASE_ANY && tts->phase != TT_PHASE_NONE){ - return 0; - } + + i = 0; + while (hysem_wait_timed(tts->started, MAX_TIME_TO_WAIT, 0) == TM_ERROR_TIMEOUT) { + i++; + printf("Thread %i hasn't started for %i milliseconds", + tts->my_index, (i * MAX_TIME_TO_WAIT)); } - // tf_assert_same(phase, tts->phase); - return 0; + hysem_post(tts->started); } -int tested_thread_is_running(tested_thread_sturct_t *tts){ +void tested_thread_wait_running(tested_thread_sturct_t *tts) { + int i; + + i = 0; + while (hysem_wait_timed(tts->running, MAX_TIME_TO_WAIT, 0) == TM_ERROR_TIMEOUT) { + i++; + printf("Thread %i isn't running after %i milliseconds", + tts->my_index, (i * MAX_TIME_TO_WAIT)); + } +} - int clicks = tts->clicks; +void tested_thread_wait_ended(tested_thread_sturct_t *tts) { int i; + + i = 0; + while (hysem_wait_timed(tts->ended, MAX_TIME_TO_WAIT, 0) == TM_ERROR_TIMEOUT) { + i++; + printf("Thread %i hasn't ended for %i milliseconds", + tts->my_index, (i * MAX_TIME_TO_WAIT)); + } + hysem_post(tts->ended); +} - for (i = 0; i < MAX_CLICKS_TO_WAIT; i++){ - sleep_a_click(); - if (clicks != tts->clicks){ - return 1; - } +void tested_thread_wait_dead(tested_thread_sturct_t *tts) { + int i; + + i = 0; + while (hythread_join_timed(tts->native_thread, MAX_TIME_TO_WAIT, 0) == TM_ERROR_TIMEOUT) { + i++; + printf("Thread %i isn't dead after %i milliseconds", + tts->my_index, (i * MAX_TIME_TO_WAIT)); } - return 0; } int compare_threads(jthread *threads, int thread_nmb, int compare_from_end) { @@ -433,16 +472,12 @@ void JNICALL default_run_for_test(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg) { - tested_thread_sturct_t * tts = current_thread_tts; + tested_thread_sturct_t * tts = (tested_thread_sturct_t *)arg; tts->phase = TT_PHASE_RUNNING; - while(1){ - tts->clicks++; - sleep_a_click(); - if (tts->stop) { - break; - } - } + tested_thread_started(tts); + tested_thread_wait_for_stop_request(tts); tts->phase = TT_PHASE_DEAD; + tested_thread_ended(tts); } Index: trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.h =================================================================== --- trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.h (revision 454602) +++ trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.h (working copy) @@ -44,11 +44,13 @@ #define TTS_INIT_DIFFERENT_MONITORS 1 #define MAX_TESTED_THREAD_NUMBER 5 -#define MAX_CLICKS_TO_WAIT 30 +#define MAX_TIME_TO_WAIT 1000 +#define MAX_OWNED_MONITORS_NMB 2 +#define SLEEP_TIME 100 #define CLICK_TIME_MSEC 10 -#define MAX_OWNED_MONITORS_NMB 2 -#define SLEEP_MSEC 10 +extern JavaVM * GLOBAL_VM; + typedef struct _jjobject{ void *data; jboolean daemon; @@ -63,20 +65,20 @@ typedef struct { int my_index; jthread java_thread; + hythread_t native_thread; jobject monitor; jrawMonitorID raw_monitor; void * jvmti_start_proc_arg; - int clicks; + hysem_t started; + hysem_t running; + hysem_t stop_request; + hysem_t ended; int phase; - int stop; jint peak_count; jthread_threadattr_t attrs; jclass excn; -}tested_thread_sturct_t; +} tested_thread_sturct_t; -extern tested_thread_sturct_t *current_thread_tts; -extern tested_thread_sturct_t *dummy_tts; -void jni_init(); void sleep_a_click(void); void test_java_thread_setup(int argc, char *argv[]); void test_java_thread_teardown(void); @@ -85,20 +87,38 @@ void tested_threads_run_common(jvmtiStartFunction run_method_param); void tested_threads_run_with_different_monitors(jvmtiStartFunction run_method_param); void tested_threads_run_with_jvmti_start_proc(jvmtiStartFunction jvmti_start_proc); -void tested_os_threads_run(apr_thread_start_t run_method_param); +void tested_os_threads_run(hythread_entrypoint_t run_method_param); + int tested_threads_destroy(); int tested_threads_stop(); + tested_thread_sturct_t *get_tts(int tts_index); int next_tested_thread(tested_thread_sturct_t **tts); int prev_tested_thread(tested_thread_sturct_t **tts); void reset_tested_thread_iterator(tested_thread_sturct_t ** tts); -int check_tested_thread_structures(tested_thread_sturct_t *tts); -int check_tested_thread_phase(tested_thread_sturct_t *tts, int phase); -int tested_thread_is_running(tested_thread_sturct_t *tts); + +#define check_tested_thread_phase(tts, phase) if (check_phase(tts, phase) != TEST_PASSED) return TEST_FAILED; +#define check_tested_thread_structures(tts) if (check_structure(tts) != TEST_PASSED) return TEST_FAILED; +int check_structure(tested_thread_sturct_t *tts); +int check_phase(tested_thread_sturct_t *tts, int phase); + +void tested_thread_started(tested_thread_sturct_t * tts); +void tested_thread_ended(tested_thread_sturct_t * tts); +void tested_thread_send_stop_request(tested_thread_sturct_t * tts); +void tested_thread_wait_for_stop_request(tested_thread_sturct_t * tts); +IDATA tested_thread_wait_for_stop_request_timed(tested_thread_sturct_t * tts, I_64 sleep_time); + +void tested_thread_wait_started(tested_thread_sturct_t *tts); +void tested_thread_wait_running(tested_thread_sturct_t *tts); +void tested_thread_wait_ended(tested_thread_sturct_t *tts); +void tested_thread_wait_dead(tested_thread_sturct_t *tts); + int compare_threads(jthread *threads, int thread_nmb, int compare_from_end); int compare_pointer_sets(void ** set_a, void ** set_b, int nmb); int check_exception(jobject excn); -jobject new_jobject(); -void delete_jobject(jobject obj); void set_phase(tested_thread_sturct_t *tts, int phase); void JNICALL default_run_for_test(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *arg); +jthread new_jobject_thread(JNIEnv * jni_env); +jobject new_jobject_thread_death(JNIEnv * jni_env); +jthread new_jobject(); +void delete_jobject(jobject obj);