harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gshiman...@apache.org
Subject svn commit: r612140 [2/2] - in /harmony/enhanced/drlvm/trunk/vm/tests/unit/thread: test_java_monitors.c test_java_park.c test_ti_instrum.c test_ti_peak_count.c test_ti_raw_monitors.c test_ti_state.c test_ti_timing.c utils/thread_unit_test_utils.c
Date Tue, 15 Jan 2008 15:47:21 GMT
Modified: harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_state.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_state.c?rev=612140&r1=612139&r2=612140&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_state.c (original)
+++ harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_state.c Tue Jan 15 07:47:20
2008
@@ -24,15 +24,15 @@
 #include <open/ti_thread.h>
 
 /*
- * Test jthread_get_jvmti_state(...)
+ * Test test_jthread_get_jvmti_state_1
  *
- *  called function          tested state
+ *  called function                     tested state
  *
- *                           Not Alive, New (state == 0)
- *  hythread_create()             ALIVE | RUNNABLE
- *  jthread_interrupt()          ALIVE | RUNNABLE | INTERRUPTED
- *  jthread_clear_interrupted()  ALIVE | RUNNABLE
- *                           DEAD
+ *  tested_threads_init()               NEW   (state == 0)
+ *  hythread_create()                   ALIVE | RUNNABLE
+ *  jthread_interrupt()                 ALIVE | RUNNABLE | INTERRUPTED
+ *  jthread_clear_interrupted()         ALIVE | RUNNABLE
+ *  tested_thread_send_stop_request()   TERMINATED
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_1(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -41,18 +41,18 @@
     tts->phase = TT_PHASE_RUNNING;
     tested_thread_started(tts);
     while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
-        hythread_safe_point();
         hythread_yield();
     }
     tts->phase = TT_PHASE_DEAD;
     tested_thread_ended(tts);
-}
+} // run_for_test_jthread_get_jvmti_state_1
 
 int test_jthread_get_jvmti_state_1(void) {
 
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
+    int count;
 
     // Initialize tts structures and run all tested threads
     tested_threads_init(TTS_INIT_COMMON_MONITOR);
@@ -60,10 +60,8 @@
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
+        ref_state = 0;   // it's a new thread
+        log_info("thread %d state = %08x (%08x) - NEW", tts->my_index, state, ref_state);
         tf_assert_same(state, ref_state);
     }
 
@@ -74,46 +72,53 @@
     while(next_tested_thread(&tts)){
         tested_thread_wait_running(tts);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x5;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state = JVMTI_THREAD_STATE_RUNNABLE | JVMTI_THREAD_STATE_ALIVE;
+        log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE", tts->my_index, state,
ref_state);
+        tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");
 
         tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x200005;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state |= JVMTI_THREAD_STATE_INTERRUPTED;
+        log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE|INTERRUPTED", tts->my_index,
state, ref_state);
+        tf_assert_same(state, ref_state);
 
         tf_assert_same(jthread_clear_interrupted(tts->java_thread), TM_ERROR_INTERRUPT);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x5;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state &= ~JVMTI_THREAD_STATE_INTERRUPTED;
+        log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE", tts->my_index, state,
ref_state);
+        tf_assert((state & ref_state) != 0 && "thread is not RUNNABLE or ALIVE");
 
         tested_thread_send_stop_request(tts);
         tested_thread_wait_ended(tts);
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
-        tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x2;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
+        count = 0;
+        while (hythread_is_alive(tts->native_thread)) {
+            // waiting when the thread goes to terminate state
+            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 TERMINATED");
+            }
         }
-        //tf_assert_same(state, ref_state);
+        tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
+        ref_state = JVMTI_THREAD_STATE_TERMINATED;
+        log_info("thread %d state = %08x (%08x) - TERMINATED", tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
-/*
- * Test jthread_get_jvmti_state(...)
+} // test_jthread_get_jvmti_state_1
+
+/**
+ * Test test_jthread_get_jvmti_state_2
+ *
+ *  called function                     tested state
+ *
+ *  jthread_monitor_enter()             ALIVE | BLOCKED
+ *  jthread_monitor_wait()              ALIVE | WAITING | OBJECT_WAIT | INDEFINITELY
+ *  jthread_monitor_notify_all()        ALIVE | RUNNABLE
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_2(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -125,6 +130,7 @@
     tested_thread_started(tts);
     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_ended(tts);
         return;
@@ -133,36 +139,39 @@
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
     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;
+        jthread_monitor_exit(monitor);
         return;
     }
-    status = jthread_monitor_exit(monitor);
+    tts->phase = TT_PHASE_RUNNING;
     // Exit critical section
-    tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_RUNNING : TT_PHASE_ERROR);
+    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;
+    }
     while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT){
-        hythread_safe_point();
         hythread_yield();
     }
     tts->phase = TT_PHASE_DEAD;
     tested_thread_ended(tts);
-}
-
-int test_jthread_get_jvmti_state_2(void) {
+} // run_for_test_jthread_get_jvmti_state_2
 
+int test_jthread_get_jvmti_state_2(void)
+{
     tested_thread_sturct_t *tts;
     jobject monitor;
-    IDATA status;
     int state;
     int ref_state;
+    int count;
 
     // Initialize tts structures and run all tested threads
     tested_threads_init(TTS_INIT_COMMON_MONITOR);
 
     // Lock monitor
-    reset_tested_thread_iterator(&tts);
-    next_tested_thread(&tts);
-    monitor = tts->monitor;
-    status = jthread_monitor_enter(monitor);
+    monitor = get_tts(0)->monitor;
+    tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
 
     // Run all tested threads
     tested_threads_run_common(run_for_test_jthread_get_jvmti_state_2);
@@ -170,64 +179,80 @@
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_MONITOR);
-        tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x401;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
+        count = 0;
+        while (!hythread_is_blocked_on_monitor_enter(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 BLOCKED_ON_MONITOR_ENTER");
+            }
         }
-        //tf_assert_same(state, ref_state);
-    }
-    // Release monitor
-    status = jthread_monitor_exit(monitor);
-
-    reset_tested_thread_iterator(&tts);
-    while(next_tested_thread(&tts)){
-        check_tested_thread_phase(tts, TT_PHASE_WAITING_ON_WAIT);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x191;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER;
+        log_info("thread %d state = %08x (%08x) - ALIVE|BLOCKED", tts->my_index, state,
ref_state);
+        tf_assert_same(state, ref_state);
     }
 
-    // Lock monitor
-    status = jthread_monitor_enter(monitor);
-    status = jthread_monitor_notify_all(monitor);
+    // Release monitor
+    tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);
 
     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);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x401;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_INDEFINITELY
+            | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
+        log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|OBJECT_WAIT|INDEFINITELY",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
-    // Release monitor
-    status = jthread_monitor_exit(monitor);
+    // Notify 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);
 
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
+        count = 0;
+        while (!hythread_is_runnable(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 RUNNABLE");
+            }
+        }
+        tf_assert_same(jthread_monitor_enter(monitor), TM_ERROR_NONE);
+        tf_assert_same(jthread_monitor_exit(monitor), TM_ERROR_NONE);
         check_tested_thread_phase(tts, TT_PHASE_RUNNING);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x5;
-        if(tts->my_index == 0){
-            printf("state = %08x (%08x)\n", state, ref_state);
-        }
-        //tf_assert_same(state, ref_state);
+        ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_RUNNABLE;
+        log_info("thread %d state = %08x (%08x) - ALIVE|RUNNABLE",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
+} // test_jthread_get_jvmti_state_2
 
 /*
- * Test jthread_get_jvmti_state(...)
+ * Test test_jthread_get_jvmti_state_3
+ *
+ *  called function                     tested state
+ *
+ *  jthread_monitor_wait(m, n)          ALIVE | WAITING | OBJECT_WAIT | WITH_TIMEOUT
+ *  tested_thread_ended()               TERMINATED
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_3(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -237,58 +262,103 @@
 
     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;
         tested_thread_ended(tts);
         return;
     }
-    // Begin critical section
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
-    status = jthread_monitor_timed_wait(monitor, 1000000, 100);
-    if (status != TM_ERROR_INTERRUPT){
+    status = jthread_monitor_timed_wait(monitor, MAX_TIME_TO_WAIT, 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;
     }
-    status = jthread_monitor_exit(monitor);
     // Exit critical section
-    tts->phase = (status == TM_ERROR_NONE ? TT_PHASE_DEAD : TT_PHASE_ERROR);
+    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_get_jvmti_state_3
 
 int test_jthread_get_jvmti_state_3(void) {
 
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
+    int count;
+    jobject monitor;
 
     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_3);
 
+    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);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x1a1;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
-        tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
+        ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
+            | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_IN_OBJECT_WAIT;
+        log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|OBJECT_WAIT|TIMEOUT",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
+    }
+
+    // Notify tested threads
+    log_info("Notify tested threads to end");
+    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);
+
+    ref_state = JVMTI_THREAD_STATE_TERMINATED;
+    reset_tested_thread_iterator(&tts);
+    while(next_tested_thread(&tts)){
+        while (hythread_is_alive(tts->native_thread)) {
+            // waiting when the thread goes to terminate state
+            hythread_sleep(SLEEP_TIME);
+            if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME))
{
+                log_info("Test thread phase: %d", tts->phase);
+                tf_fail("thread failed to change state on TERMINATED");
+            }
+        }
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x2;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
+        log_info("thread %d state = %08x (%08x) - TERMINATED",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
+} // test_jthread_get_jvmti_state_3
 
-/*
- * Test jthread_get_jvmti_state(...)
+/**
+ * Test test_jthread_get_jvmti_state_4
+ *
+ * 1. Run threads
+ * 2. Wait 20 times more then 1 thread does
+ * 3. Expected TERMINATED state for all threads
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_4(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -300,6 +370,7 @@
     tested_thread_started(tts);
     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_ended(tts);
         return;
@@ -308,21 +379,28 @@
     tts->phase = TT_PHASE_WAITING_ON_WAIT;
     status = jthread_monitor_timed_wait(monitor, CLICK_TIME_MSEC, 0);
     if (status != TM_ERROR_TIMEOUT){
+        log_info("Test status is %d, but expected %d", 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);
+    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);
-}
-
-int test_jthread_get_jvmti_state_4(void) {
+} // run_for_test_jthread_get_jvmti_state_4
 
+int test_jthread_get_jvmti_state_4(void)
+{
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
+    int count;
 
     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_4);
@@ -333,20 +411,39 @@
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
+    }
+
+    ref_state = JVMTI_THREAD_STATE_TERMINATED;
+    reset_tested_thread_iterator(&tts);
+    while(next_tested_thread(&tts)){
+        count = 0;
+        while (hythread_is_alive(tts->native_thread)) {
+            // waiting when the thread goes to terminate state
+            hythread_sleep(SLEEP_TIME);
+            if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME))
{
+                log_info("Test thread phase: %d", tts->phase);
+                tf_fail("thread failed to change state on TERMINATED");
+            }
+        }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x2;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
+        log_info("thread %d state = %08x (%08x) - TERMINATED",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
+} // test_jthread_get_jvmti_state_4
 
-/*
- * Test jthread_get_jvmti_state(...)
+/**
+ * Test test_jthread_get_jvmti_state_5
+ *
+ * 1. Run threads
+ * 2. Check sleeping state
+ * 3. Interrupt sleep
+ * 4. Check TERMINATE state
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_5(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -355,43 +452,76 @@
 
     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);
+    status = jthread_sleep(MAX_TIME_TO_WAIT, 0);
+    if (status != TM_ERROR_INTERRUPT) {
+        log_info("Test status is %d, but expected %d", status, TM_ERROR_INTERRUPT);
+        tts->phase = TT_PHASE_ERROR;
+    } else {
+        tts->phase = TT_PHASE_DEAD;
+    }
     tested_thread_ended(tts);
-}
-
-int test_jthread_get_jvmti_state_5(void) {
+} // run_for_test_jthread_get_jvmti_state_5
 
+int test_jthread_get_jvmti_state_5(void)
+{
     tested_thread_sturct_t *tts;
     int state;
     int ref_state;
+    int count;
 
     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_5);
 
     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_SLEEPING);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
+        ref_state = JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT
+            | JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_SLEEPING;
+        log_info("thread %d state = %08x (%08x) - ALIVE|WAITING|SLEEPING|TIMEOUT",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
         tf_assert_same(jthread_interrupt(tts->java_thread), TM_ERROR_NONE);
+    }
+
+    ref_state = JVMTI_THREAD_STATE_TERMINATED;
+    reset_tested_thread_iterator(&tts);
+    while(next_tested_thread(&tts)){
+        count = 0;
+        while (hythread_is_alive(tts->native_thread)) {
+            // waiting when the thread goes to terminate state
+            hythread_sleep(SLEEP_TIME);
+            if (tts->phase == TT_PHASE_ERROR || ++count > (MAX_TIME_TO_WAIT/SLEEP_TIME))
{
+                log_info("Test thread phase: %d", tts->phase);
+                tf_fail("thread failed to change state on TERMINATED");
+            }
+        }
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
+        log_info("thread %d state = %08x (%08x) - TERMINATED",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
-
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
+} // test_jthread_get_jvmti_state_5
 
-/*
- * Test jthread_get_jvmti_state(...)
+/**
+ * Test test_jthread_get_jvmti_state_6
+ *
+ * 1. Run threads
+ * 2. Wait 20 times more then 1 thread does
+ * 3. Expected TERMINATED state for all threads
  */
 void JNICALL run_for_test_jthread_get_jvmti_state_6(jvmtiEnv * jvmti_env, JNIEnv * jni_env,
void *args){
 
@@ -401,15 +531,21 @@
     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);
+    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);
-}
-
-int test_jthread_get_jvmti_state_6(void) {
+} // run_for_test_jthread_get_jvmti_state_6
 
-    tested_thread_sturct_t *tts;
+int test_jthread_get_jvmti_state_6(void)
+{
+    int count;
     int state;
     int ref_state;
+    tested_thread_sturct_t *tts;
 
     // Initialize tts structures and run all tested threads
     tested_threads_run(run_for_test_jthread_get_jvmti_state_6);
@@ -417,26 +553,35 @@
     // Wait for all threads wait timeout
     jthread_sleep(20 * CLICK_TIME_MSEC * MAX_TESTED_THREAD_NUMBER, 0);
 
+    ref_state = JVMTI_THREAD_STATE_TERMINATED;
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
         check_tested_thread_phase(tts, TT_PHASE_DEAD);
+        count = 0;
+        while (hythread_is_alive(tts->native_thread)) {
+            // waiting when the thread goes to terminate state
+            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 TERMINATED");
+            }
+        }
         tf_assert_same(jthread_get_jvmti_state(tts->java_thread, &state), TM_ERROR_NONE);
-        ref_state = 0x2;
-        printf("state = %08x (%08x)\n", state, ref_state);
-        //tf_assert_same(state, ref_state);
+        log_info("thread %d state = %08x (%08x) - TERMINATED",
+            tts->my_index, state, ref_state);
+        tf_assert_same(state, ref_state);
     }
 
     // Terminate all threads and clear tts structures
     tested_threads_destroy();
 
     return TEST_PASSED;
-}
+} // test_jthread_get_jvmti_state_6
 
 TEST_LIST_START
-    //TEST(test_jthread_get_jvmti_state_1)
-    //TEST(test_jthread_get_jvmti_state_2)
-    //TEST(test_jthread_get_jvmti_state_3)
-    //TEST(test_jthread_get_jvmti_state_4)
-    //TEST(test_jthread_get_jvmti_state_5)
+    TEST(test_jthread_get_jvmti_state_1)
+    TEST(test_jthread_get_jvmti_state_2)
+    TEST(test_jthread_get_jvmti_state_3)
+    TEST(test_jthread_get_jvmti_state_4)
+    TEST(test_jthread_get_jvmti_state_5)
     TEST(test_jthread_get_jvmti_state_6)
 TEST_LIST_END;

Modified: harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_timing.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_timing.c?rev=612140&r1=612139&r2=612140&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_timing.c (original)
+++ harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/test_ti_timing.c Tue Jan 15 07:47:20
2008
@@ -23,115 +23,110 @@
 #include <open/hythread_ext.h>
 #include <open/ti_thread.h>
 
-int helper_hythread_cpu_timing(void);
-
-/*
- * CPU timing
- */
-
-int test_jthread_get_thread_cpu_time(void) {
-
-    log_info("NO IMPLEMENTTATION TO TEST");
-    return TEST_FAILED;
-    return helper_hythread_cpu_timing();
-}
-
-int test_jthread_get_thread_user_cpu_time(void) {
-
-    log_info("NO IMPLEMENTTATION TO TEST");
-    return TEST_FAILED;
-    return helper_hythread_cpu_timing();
-}
-
-int test_jthread_get_thread_blocked_time(void) {
-
-    log_info("NO IMPLEMENTTATION TO TEST");
-    return TEST_FAILED;
-    return helper_hythread_cpu_timing();
-}
-
-int test_jthread_get_thread_waited_time(void) {
-
-    log_info("NO IMPLEMENTTATION TO TEST");
-    return TEST_FAILED;
-    return helper_hythread_cpu_timing();
-}
-
-int test_jthread_get_thread_cpu_timer_info(void) {
-
-    log_info("NO IMPLEMENTTATION TO TEST");
-    return TEST_FAILED;
-    return helper_hythread_cpu_timing();
-}
-
-void JNICALL run_for_helper_hythread_cpu_timing(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void
*args){
-
+void JNICALL run_for_helper_get_timing(jvmtiEnv * jvmti_env, JNIEnv * jni_env, void *args)
+{
     tested_thread_sturct_t * tts = (tested_thread_sturct_t *) args;
     int num = 0;
-    
+    jobject monitor = tts->monitor;
+    IDATA status;
+
     tts->phase = TT_PHASE_RUNNING;
     tested_thread_started(tts);
-    while(tested_thread_wait_for_stop_request_timed(tts, SLEEP_TIME) == TM_ERROR_TIMEOUT)
{
+    while(tested_thread_wait_for_stop_request_timed(tts, 1) == TM_ERROR_TIMEOUT) {
+        status = jthread_monitor_enter(monitor);
+        if (status != TM_ERROR_NONE){
+            tts->phase = TT_PHASE_ERROR;
+            tested_thread_ended(tts);
+            return;
+        }
+        status = jthread_monitor_timed_wait(monitor, 0, 100);
+        if (status != TM_ERROR_TIMEOUT) {
+            tts->phase = TT_PHASE_ERROR;
+            jthread_monitor_exit(monitor);
+            break;
+        }
+        status = jthread_monitor_exit(monitor);
+        if (status != TM_ERROR_NONE) {
+            tts->phase = TT_PHASE_ERROR;
+            break;
+        }
         ++num;
+        hythread_yield();
     }
+    log_info("Thread %d cycle times: %d", tts->my_index, num);
     tts->phase = TT_PHASE_DEAD;
     tested_thread_ended(tts);
-}
-
-int helper_hythread_cpu_timing(void) {
+} // run_for_helper_get_timing
 
+int test_jthread_get_timing(void)
+{
     tested_thread_sturct_t *tts;
     jlong cpu_time;
     jlong user_cpu_time;
     jlong blocked_time;
     jlong waited_time;
-    jvmtiTimerInfo timer_info;
-
-    log_info("NO IMPLEMENTATION TO TEST");
-    return TEST_FAILED;
 
     // Initialize tts structures and run all tested threads
-    tested_threads_run(run_for_helper_hythread_cpu_timing);
+    tested_threads_run(run_for_helper_get_timing);
+
+    hythread_sleep(MAX_TIME_TO_WAIT/20);
     
     reset_tested_thread_iterator(&tts);
     while(next_tested_thread(&tts)){
-        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);
         tf_assert_same(jthread_get_thread_user_cpu_time(tts->java_thread, &user_cpu_time),
TM_ERROR_NONE);
         tf_assert_same(jthread_get_thread_blocked_time(tts->java_thread, &blocked_time),
TM_ERROR_NONE);
         tf_assert_same(jthread_get_thread_waited_time(tts->java_thread, &waited_time),
TM_ERROR_NONE);
-        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);
-        printf("blocked_time = %i \n", blocked_time);
-        printf("waited_time = %i \n", waited_time);
-        printf("cpu_time = %i \n", cpu_time);
-
-        printf("jvmtiTimerInfo :\n");
-        printf("max_value = %i \n", timer_info.max_value);
-        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);
-        */
+
+        log_info("Thread %d:", tts->my_index);
+        if (cpu_time/1000000) {
+            log_info("cpu_time = %.1f s", (float)cpu_time/1000000);
+        } else if(cpu_time/1000) {
+            log_info("cpu_time = %.1f ms", (float)cpu_time/1000);
+        } else {
+            log_info("cpu_time = %d ns", cpu_time);
+        }
+
+        if (user_cpu_time/1000000) {
+            log_info("user_cpu_time = %.1f s", (float)user_cpu_time/1000000);
+        } else if(user_cpu_time/1000) {
+            log_info("user_cpu_time = %.1f ms", (float)user_cpu_time/1000);
+        } else {
+            log_info("user_cpu_time = %d ns", user_cpu_time);
+        }
+
+        if (blocked_time/1000000) {
+            log_info("blocked_time = %.1f s", (float)blocked_time/1000000);
+        } else if (blocked_time/1000) {
+            log_info("blocked_time = %.1f ms", (float)blocked_time/1000);
+        } else {
+            log_info("blocked_time = %d ns", blocked_time);
+        }
+
+        if (waited_time/1000000) {
+            log_info("waited_time = %.1f s\n", (float)waited_time/1000000);
+        } else if (waited_time/1000) {
+            log_info("waited_time = %.1f ms\n", (float)waited_time/1000);
+        } else {
+            log_info("waited_time = %d ns\n", waited_time);
+        }
+    }
+
+    reset_tested_thread_iterator(&tts);
+    while(next_tested_thread(&tts)) {
+        tested_thread_send_stop_request(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_get_timing
 
 TEST_LIST_START
-    //TEST(test_jthread_get_thread_cpu_time)
-    //TEST(test_jthread_get_thread_user_cpu_time)
-    //TEST(test_jthread_get_thread_waited_time)
-    //TEST(test_jthread_get_thread_blocked_time)
-    //TEST(test_jthread_get_thread_cpu_timer_info)
+    TEST(test_jthread_get_timing)
 TEST_LIST_END;

Modified: harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c?rev=612140&r1=612139&r2=612140&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c (original)
+++ harmony/enhanced/drlvm/trunk/vm/tests/unit/thread/utils/thread_unit_test_utils.c Tue Jan
15 07:47:20 2008
@@ -350,7 +350,8 @@
     tf_assert(tts->phase != TT_PHASE_ERROR);
     if (phase == TT_PHASE_ANY) {
         tf_assert(tts->phase != TT_PHASE_NONE);
-    } else {
+    } else if (tts->phase != phase) {
+        log_info("Expected phase %d, but got %d", phase, tts->phase);
         tf_assert_same(tts->phase, phase);
     }
     return TEST_PASSED;
@@ -386,7 +387,7 @@
     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", 
+        log_info("Thread %i hasn't ended for %i milliseconds",
             tts->my_index, (i * MAX_TIME_TO_WAIT));
     }
     hysem_post(tts->ended);
@@ -403,7 +404,7 @@
         if(!hythread_is_alive(native_thread)) {
             break;
         }
-        if ((i % (MAX_TIME_TO_WAIT / SLEEP_TIME)) == 0) {
+        if (!i && (i % (MAX_TIME_TO_WAIT / SLEEP_TIME)) == 0) {
             printf("Thread %i isn't dead after %i milliseconds",
                 index, (++i * SLEEP_TIME));
         }



Mime
View raw message