| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| #include "testframe.h" |
| #include "thread_unit_test_utils.h" |
| #include <jthread.h> |
| #include <open/hythread_ext.h> |
| |
| static hysem_t mon_enter; |
| |
| /** |
| * Monitor TODO: |
| * |
| * - Init monitor and not init |
| * - jthread_monitor_exit() without jthread_monitor_enter() |
| */ |
| |
| /** |
| * Test jthread_monitor_try_enter() |
| */ |
| void JNICALL run_for_test_jthread_monitor_try_enter(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| 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); |
| // Begin critical section |
| status = jthread_monitor_try_enter(monitor); |
| while (status == TM_ERROR_EBUSY){ |
| status = jthread_monitor_try_enter(monitor); |
| sleep_a_click(); |
| } |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_IN_CRITICAL_SECTON; |
| } |
| hysem_set(mon_enter, 1); |
| tested_thread_wait_for_stop_request(tts); |
| status = jthread_monitor_exit(monitor); |
| // End critical section |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_try_enter |
| |
| int test_jthread_monitor_try_enter(void) |
| { |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *critical_tts; |
| int i; |
| int waiting_on_monitor_nmb; |
| |
| tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE); |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_try_enter); |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++) { |
| waiting_on_monitor_nmb = 0; |
| critical_tts = NULL; |
| |
| tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)) { |
| if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON) { |
| // error if two threads in critical section |
| tf_assert(critical_tts == NULL); |
| critical_tts = tts; |
| } else if (tts->phase == TT_PHASE_WAITING_ON_MONITOR) { |
| waiting_on_monitor_nmb++; |
| } |
| } |
| tf_assert(critical_tts); // thread in critical section found |
| if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_monitor_nmb + 1){ |
| tf_fail("Wrong number waiting on monitor threads"); |
| } |
| log_info("Thread %d grabbed monitor", critical_tts->my_index); |
| 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 |
| tested_threads_destroy(); |
| |
| tf_assert_same(hysem_destroy(mon_enter), TM_ERROR_NONE); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_try_enter |
| |
| /** |
| * Test jthread_monitor_notify_all() |
| * Test jthread_monitor_notify() |
| */ |
| void JNICALL run_for_test_jthread_monitor_notify(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", 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); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_IN_CRITICAL_SECTON; |
| } |
| hysem_set(mon_enter, 1); |
| tested_thread_wait_for_stop_request(tts); |
| // Exit critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_notify |
| |
| int test_jthread_monitor_notify_all(void) |
| { |
| int i; |
| int count; |
| int waiting_on_wait_nmb; |
| jobject monitor; |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *critical_tts; |
| |
| tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE); |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_notify); |
| |
| monitor = get_tts(0)->monitor; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)) { |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| log_info("Notify all tested threads"); |
| 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); |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++) { |
| waiting_on_wait_nmb = 0; |
| critical_tts = NULL; |
| |
| tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ |
| tf_assert(critical_tts == NULL); // error if two threads in critical section |
| critical_tts = tts; |
| } else if (tts->phase == TT_PHASE_WAITING_ON_WAIT){ |
| waiting_on_wait_nmb++; |
| } |
| } |
| tf_assert(critical_tts); // thread in critical section found |
| if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_wait_nmb + 1){ |
| tf_fail("Wrong number waiting on monitor threads"); |
| } |
| log_info("Thread %d was notified", critical_tts->my_index); |
| 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 |
| tested_threads_destroy(); |
| |
| tf_assert_same(hysem_destroy(mon_enter), TM_ERROR_NONE); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_notify_all |
| |
| int test_jthread_monitor_notify(void) |
| { |
| int i; |
| int count; |
| int waiting_on_wait_nmb; |
| jobject monitor; |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *critical_tts; |
| |
| tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE); |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_notify); |
| |
| monitor = get_tts(0)->monitor; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)) { |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++){ |
| waiting_on_wait_nmb = 0; |
| critical_tts = NULL; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| tf_assert(tts->phase != TT_PHASE_IN_CRITICAL_SECTON); |
| } |
| |
| log_info("Notify monitor"); |
| tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE); |
| tf_assert_same(jthread_monitor_notify(monitor), TM_ERROR_NONE); |
| tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE); |
| |
| tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)) { |
| if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON) { |
| // error if two threads in critical section |
| tf_assert(critical_tts == NULL); |
| critical_tts = tts; |
| } else if (tts->phase == TT_PHASE_WAITING_ON_WAIT) { |
| waiting_on_wait_nmb++; |
| } |
| } |
| tf_assert(critical_tts); // thread in critical section found |
| if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_wait_nmb + 1){ |
| tf_fail("Wrong number waiting on monitor threads"); |
| } |
| log_info("Thread %d was notified", critical_tts->my_index); |
| 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 |
| tested_threads_destroy(); |
| |
| tf_assert_same(hysem_destroy(mon_enter), TM_ERROR_NONE); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_notify |
| |
| /** |
| * Test jthread_monitor_wait() |
| */ |
| void JNICALL run_for_test_jthread_monitor_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE){ |
| log_info("Test status is %d, but expected %d", 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); |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_wait |
| |
| int test_jthread_monitor_wait(void) |
| { |
| int count; |
| tested_thread_sturct_t *tts; |
| jobject monitor; |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_wait); |
| |
| monitor = get_tts(0)->monitor; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| log_info("Notify all threads"); |
| 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); |
| |
| 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 |
| tested_threads_destroy(); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_wait |
| |
| /* |
| * Test jthread_monitor_wait_interrupt() |
| */ |
| void JNICALL run_for_test_jthread_monitor_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", 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) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_INTERRUPT); |
| tts->phase = TT_PHASE_ERROR; |
| jthread_monitor_exit(monitor); |
| tested_thread_ended(tts); |
| return; |
| } |
| // Exit critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_wait_interrupt |
| |
| int test_jthread_monitor_wait_interrupt(void) |
| { |
| int i; |
| int count; |
| int waiting_on_wait_nmb; |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *waiting_tts; |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_wait_interrupt); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER + 1; i++) { |
| waiting_on_wait_nmb = 0; |
| waiting_tts = NULL; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| if (tts->phase == TT_PHASE_WAITING_ON_WAIT) { |
| waiting_tts = tts; |
| waiting_on_wait_nmb++; |
| } else { |
| check_tested_thread_phase(tts, TT_PHASE_DEAD); |
| } |
| } |
| tf_assert_same(MAX_TESTED_THREAD_NUMBER - i, waiting_on_wait_nmb); |
| if (waiting_tts) { |
| log_info("Interrupt thread %d", waiting_tts->my_index); |
| 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); |
| } |
| } |
| // Terminate all threads and clear tts structures |
| tested_threads_destroy(); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_wait_interrupt |
| |
| /* |
| * Test jthread_monitor_timed_wait() |
| */ |
| void JNICALL run_for_test_jthread_monitor_timed_wait(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", 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_NONE){ |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| jthread_monitor_exit(monitor); |
| tested_thread_ended(tts); |
| return; |
| } |
| // Exit critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_timed_wait |
| |
| int test_jthread_monitor_timed_wait(void) |
| { |
| int count; |
| tested_thread_sturct_t *tts; |
| jobject monitor; |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_timed_wait); |
| |
| monitor = get_tts(0)->monitor; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| log_info("Notify all threads"); |
| 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); |
| |
| 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 |
| tested_threads_destroy(); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_timed_wait |
| |
| /* |
| * Test jthread_monitor_timed_wait() |
| */ |
| void JNICALL run_for_test_jthread_monitor_timed_wait_timeout(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", 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; |
| } |
| // Exit critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_timed_wait_timeout |
| |
| int test_jthread_monitor_timed_wait_timeout(void) |
| { |
| int count; |
| tested_thread_sturct_t *tts; |
| jobject monitor; |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_timed_wait_timeout); |
| |
| monitor = get_tts(0)->monitor; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| // Wait for all threads wait timeout |
| hythread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER); |
| |
| 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 |
| tested_threads_destroy(); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_timed_wait_timeout |
| |
| /* |
| * Test jthread_monitor_timed_wait() |
| */ |
| void JNICALL run_for_test_jthread_monitor_timed_wait_interrupt(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| IDATA status; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", 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) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_INTERRUPT); |
| tts->phase = TT_PHASE_ERROR; |
| jthread_monitor_exit(monitor); |
| tested_thread_ended(tts); |
| return; |
| } |
| // Exit critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_timed_wait_interrupt |
| |
| int test_jthread_monitor_timed_wait_interrupt(void) |
| { |
| int i; |
| int count; |
| int waiting_on_wait_nmb; |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *waiting_tts; |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_timed_wait_interrupt); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| count = 0; |
| while (!hythread_is_waiting(tts->native_thread)) { |
| // wait until the state is changed |
| hythread_sleep(SLEEP_TIME); |
| if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME)) { |
| tf_fail("thread failed to change state on WAITING"); |
| } |
| } |
| check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT); |
| log_info("Thread %d is waiting.", tts->my_index); |
| } |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER + 1; i++) { |
| waiting_on_wait_nmb = 0; |
| waiting_tts = NULL; |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| if (tts->phase == TT_PHASE_WAITING_ON_WAIT) { |
| waiting_tts = tts; |
| waiting_on_wait_nmb++; |
| } else { |
| check_tested_thread_phase(tts, TT_PHASE_DEAD); |
| } |
| } |
| tf_assert_same(MAX_TESTED_THREAD_NUMBER - i, waiting_on_wait_nmb); |
| if (waiting_tts) { |
| log_info("Interrupt thread %d", waiting_tts->my_index); |
| 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); |
| } |
| } |
| // Terminate all threads and clear tts structures |
| tested_threads_destroy(); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_timed_wait_interrupt |
| |
| /** |
| * Test jthread_monitor_enter() |
| * Test jthread_monitor_exit() |
| */ |
| void JNICALL run_for_test_jthread_monitor_enter_exit(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args) |
| { |
| IDATA status; |
| tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args; |
| jobject monitor = tts->monitor; |
| |
| tts->phase = TT_PHASE_WAITING_ON_MONITOR; |
| tested_thread_started(tts); |
| // Begin critical section |
| status = jthread_monitor_enter(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_IN_CRITICAL_SECTON; |
| } |
| hysem_set(mon_enter, 1); |
| tested_thread_wait_for_stop_request(tts); |
| // End critical section |
| status = jthread_monitor_exit(monitor); |
| if (status != TM_ERROR_NONE) { |
| log_info("Test status is %d, but expected %d", status, TM_ERROR_NONE); |
| tts->phase = TT_PHASE_ERROR; |
| } else { |
| tts->phase = TT_PHASE_DEAD; |
| } |
| tested_thread_ended(tts); |
| } // run_for_test_jthread_monitor_enter_exit |
| |
| int test_jthread_monitor_enter_exit(void) |
| { |
| int i; |
| int waiting_on_monitor_nmb; |
| tested_thread_sturct_t *tts; |
| tested_thread_sturct_t *critical_tts; |
| |
| tf_assert_same(hysem_create(&mon_enter, 0, 1), TM_ERROR_NONE); |
| |
| // Initialize tts structures and run all tested threads |
| tested_threads_run(run_for_test_jthread_monitor_enter_exit); |
| |
| for (i = 0; i < MAX_TESTED_THREAD_NUMBER; i++) { |
| waiting_on_monitor_nmb = 0; |
| critical_tts = NULL; |
| |
| tf_assert_same(hysem_wait(mon_enter), TM_ERROR_NONE); |
| |
| reset_tested_thread_iterator(&tts); |
| while(next_tested_thread(&tts)){ |
| if (tts->phase == TT_PHASE_IN_CRITICAL_SECTON){ |
| tf_assert(critical_tts == NULL); // error if two threads in critical section |
| critical_tts = tts; |
| } else if (tts->phase == TT_PHASE_WAITING_ON_MONITOR){ |
| waiting_on_monitor_nmb++; |
| } |
| } |
| tf_assert(critical_tts); // thread in critical section found |
| if (MAX_TESTED_THREAD_NUMBER - i != waiting_on_monitor_nmb + 1){ |
| tf_fail("Wrong number waiting on monitor threads"); |
| } |
| log_info("Thread %d grabbed the monitor", critical_tts->my_index); |
| 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 |
| tested_threads_destroy(); |
| |
| tf_assert_same(hysem_destroy(mon_enter), TM_ERROR_NONE); |
| |
| return TEST_PASSED; |
| } // test_jthread_monitor_enter_exit |
| |
| TEST_LIST_START |
| TEST(test_jthread_monitor_enter_exit) |
| TEST(test_jthread_monitor_try_enter) |
| TEST(test_jthread_monitor_notify) |
| TEST(test_jthread_monitor_notify_all) |
| TEST(test_jthread_monitor_wait) |
| TEST(test_jthread_monitor_wait_interrupt) |
| TEST(test_jthread_monitor_timed_wait) |
| TEST(test_jthread_monitor_timed_wait_timeout) |
| TEST(test_jthread_monitor_timed_wait_interrupt) |
| TEST_LIST_END; |
