export_paje.c

linux下的多线程调试工具

                == -1) return -1;
            create_object (tn[1], "mutex");
            set_object_state (tn[1], "mutex_state", "MUTEX_STATE_FREE");
            set_object_variable (tn[1], "mutex_count", 0);
            break;
        case EVT_THREAD_SET_PD :
            create_object (tn[1], "thread");
            push_object_state (tn[1], "thread_func", "USER_IN");
            if (show_state) set_object_state (tn[1], "thread_state",
                                              "THREAD_STATE_WAKE");
            if (show_attr) set_object_state (tn[1], "thread_attr",
                                             "THREAD_JOINABLE");
            break;
        case EVT_START_USER_FUNC :
            /* create main thread and program */
            create_prog ();
            create_object (tn[0], "thread");
            push_object_state (tn[0], "thread_func", "USER_IN");
            if (show_state) set_object_state (tn[0], "thread_state",
                                              "THREAD_STATE_WAKE");
            if (show_attr) set_object_state (tn[0], "thread_attr",
                                             "THREAD_JOINABLE");
        break;
        default: break;
    }
    /* handle links */
    switch (event) {
        /* barrier */
        case EVT_BARRIER_LOCK_FREE :
        case EVT_BARRIER_LOCK_REQUIRE :
        case EVT_BARRIER_LEFT_DEC :
        case EVT_BARRIER_LEFT_INC :
        case EVT_BARRIER_INIT :
        case EVT_BARRIER_DESTROY :
            link_objects (tn[0], tn[1], "thread-barrier", "th-ba_col");
            break;
        /* conditionnal variable */
        case EVT_COND_LOCK_FREE :
        case EVT_COND_LOCK_REQUIRE :
        case EVT_COND_INIT :
        case EVT_COND_DESTROY :
            link_objects (tn[0], tn[1], "thread-cond", "th-co_col");
            break;
        /* conditionnal variable and mutex */
        case EVT_COND_MUTEX_FREE :
        case EVT_COND_MUTEX_REQUIRE :
            link_objects (tn[2], tn[1], "cond-mutex", "co-mu_col");
            break;
        /* mutex */
        case EVT_MUTEX_STATE_FREE :
        case EVT_MUTEX_STATE_REQUIRE :
        case EVT_MUTEX_COUNT_DEC :
        case EVT_MUTEX_COUNT_INC :
        case EVT_MUTEX_INIT :
        case EVT_MUTEX_DESTROY :
            link_objects (tn[0], tn[1], "thread-mutex", "th-mu_col");
            break;
        /* thread */
        case EVT_THREAD_SET_PD :
        case EVT_THREAD_JOIN :
        case EVT_THREAD_STATE_CANCEL :
            link_objects (tn[0], tn[1], "thread-thread", "th-th_col");
        default: break;
    }
    /* handle the rest : states, variables, events, destruction */
    switch (event) {    
        /* *_IN */
        case EVT_BARRIER_INIT_IN :
        case EVT_COND_INIT_IN :
        case EVT_MUTEX_INIT_IN :
        case EVT_THREAD_CREATE_IN :
            push_object_state (tn[0], "thread_func", evt_data->name);
            break;
        case EVT_BARRIER_DESTROY_IN :
        case EVT_BARRIER_WAIT_IN :
            push_object_state (tn[0], "thread_func", evt_data->name);
            if (IO_only)
                link_objects (tn[0], tn[1], "thread-barrier", "th-ba_col");
            break;
        case EVT_THREAD_CANCEL_IN :
        case EVT_THREAD_JOIN_IN :
            push_object_state (tn[0], "thread_func", evt_data->name);
            if (IO_only)
                link_objects (tn[0], tn[1], "thread-thread", "th-th_col");
            break;
        case EVT_COND_DESTROY_IN :
        case EVT_COND_BROAD_IN :
        case EVT_COND_SIGNAL_IN :
        case EVT_COND_WAIT_IN :
            push_object_state (tn[0], "thread_func", evt_data->name);
            if (IO_only)
                link_objects (tn[0], tn[1], "thread-cond", "th-co_col");
            break;
        case EVT_MUTEX_DESTROY_IN :
        case EVT_MUTEX_LOCK_IN :
        case EVT_MUTEX_UNLOCK_IN :
            push_object_state (tn[0], "thread_func", evt_data->name);
            if (IO_only)
                link_objects (tn[0], tn[1], "thread-mutex", "th-mu_col");
            break;
        /* *_OUT */
        case EVT_BARRIER_DESTROY_OUT :
        case EVT_BARRIER_INIT_OUT :
        case EVT_COND_DESTROY_OUT :
        case EVT_COND_INIT_OUT :
        case EVT_COND_BROAD_OUT :
        case EVT_COND_SIGNAL_OUT :
        case EVT_COND_WAIT_OUT :
        case EVT_MUTEX_DESTROY_OUT :
        case EVT_MUTEX_INIT_OUT :
        case EVT_MUTEX_LOCK_OUT :
        case EVT_MUTEX_UNLOCK_OUT :
        case EVT_THREAD_CANCEL_OUT :
        case EVT_THREAD_CREATE_OUT :
        case EVT_THREAD_JOIN_OUT :
            pop_object_state (tn[0], "thread_func");
            /* show if return value is incorrect */
            if (ti[0] != 0) new_event (tn[0], "ret_val");
            break;
        case EVT_BARRIER_WAIT_OUT :
            pop_object_state (tn[0], "thread_func");
            /* show if return value is incorrect */
            if (ti[0] != 0 && ti[0] != PTHREAD_BARRIER_SERIAL_THREAD)
                new_event (tn[0], "ret_val");
            break;
        /* THREAD_STATE_* */
        case EVT_THREAD_STATE_CANCEL :
            if (show_state) set_object_state (tn[1], "thread_state",
                                              evt_data->name);
            break;
        case EVT_THREAD_STATE_DEAD :
        case EVT_THREAD_STATE_WAIT :
        case EVT_THREAD_STATE_WAKE :
        case EVT_THREAD_STATE_WAIT_MUTEX :
        case EVT_THREAD_STATE_WAKE_MUTEX :
        case EVT_THREAD_STATE_WAIT_BARRIER :
        case EVT_THREAD_STATE_WAKE_BARRIER :
        case EVT_THREAD_STATE_WAIT_COND :
        case EVT_THREAD_STATE_WAKE_COND :
        case EVT_THREAD_STATE_WAIT_SEM :
        case EVT_THREAD_STATE_WAKE_SEM :
            if (show_state) set_object_state (tn[0], "thread_state",
                                              evt_data->name);
            break;
        /* THREAD attribute */
        case EVT_THREAD_DETACH :
            if (show_attr) set_object_state (tn[1], "thread_attr",
                                             evt_data->name);
            break;
        /* EVT_BARRIER_LOCK_* */
        case EVT_BARRIER_LOCK_FREE :
        case EVT_BARRIER_LOCK_TAKEN :
            set_object_state (tn[1], "barrier_state", evt_data->name);
            break;
        /* EVT_COND_LOCK_* */
        case EVT_COND_LOCK_FREE :
        case EVT_COND_LOCK_TAKEN :
            set_object_state (tn[1], "cond_state", evt_data->name);
            break;
        /* EVT_MUTEX_STATE_* */
        case EVT_MUTEX_STATE_FREE :		
        case EVT_MUTEX_STATE_TAKEN :
            set_object_state (tn[1], "mutex_state", evt_data->name);
            break;
        /* _DESTROY */
        case EVT_BARRIER_DESTROY :
            destroy_object (tn[1], "barrier");
            break;
        case EVT_COND_DESTROY :
            destroy_object (tn[1], "cond");
            break;
        case EVT_MUTEX_DESTROY :
            destroy_object (tn[1], "mutex");
            break;
        case EVT_THREAD_JOIN :
            destroy_object (tn[1], "thread");
            break;
        case EVT_END_USER_FUNC :
            destroy_object (tn[0], "thread");
            destroy_prog ();
            break;
        /* *_BARRIER_LEFT_* */
        case EVT_BARRIER_LEFT_DEC :
            dec_object_variable (tn[1], "barrier_left");
            break;
        case EVT_BARRIER_LEFT_INC :
            inc_object_variable (tn[1], "barrier_left");
            break;
        /* *_MUTEX_COUNT_* */
        case EVT_MUTEX_COUNT_DEC :
            dec_object_variable (tn[1], "mutex_count");
            break;
        case EVT_MUTEX_COUNT_INC :
            inc_object_variable (tn[1], "mutex_count");
            break;
        default: break;
    }
    return 0;
}

static void free_key (gpointer key, gpointer value, gpointer data) {
    free (key);
}

static void close () {
    int ind;
    /* free memory allocated for hash tables */
    for (ind = 0; ind < TABLE_SZ; ind++) {
        if (mutex_hash_table[ind] != NULL) {
            g_hash_table_foreach (mutex_hash_table[ind], free_key, NULL);
            g_hash_table_destroy (mutex_hash_table[ind]);
        }
        if (cond_hash_table[ind] != NULL) {
            g_hash_table_foreach (cond_hash_table[ind], free_key, NULL);
            g_hash_table_destroy (cond_hash_table[ind]);
        }
    }
}

struct export export_paje = {
    .init = init, 
    .init_file = init_file, 
    .write = write_paje, 
    .close = close
};