hprof_monitor.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 596 行 · 第 1/2 页

	return;
    }

    mon = info->mon;
    
    if (CVMlongLt(mon->time, jlong_zero)) {
        fprintf(stderr,
		"HPROF ERROR: contended monitor, entered instead of enter\n");
	return;
    } 
    
    if (mon->type != type) {
        fprintf(stderr, "HPROF ERROR: contended monitor, type mismatch\n");
	return;
    }
    
    if (mon->mon_info != mon_info) {
        fprintf(stderr, "HPROF ERROR: contended monitor, monitor mismatch\n");
	return;
    }
	    
    htrace = hprof_get_trace(env_id, max_trace_depth);
    mon->trace_serial_num = htrace->serial_num;
    imon = hprof_hash_lookup(&hprof_contended_monitor_table, mon);
    if (imon == NULL) {
        mon->time = jlong_sub(cur_time, mon->time);
	mon->num_hits = 1;
	hprof_hash_put(&hprof_contended_monitor_table, mon);
    } else {
        imon->time = jlong_add(imon->time, jlong_sub(cur_time, mon->time));
	imon->num_hits++;
    }

    info->mon->time = jint_to_jlong(-1);
}
    
void hprof_raw_monitor_event(JVMPI_Event *event,
                             const char *name,
			     JVMPI_RawMonitor mid)
{
    jlong cur_time;
    hprof_name_t *hname;
    hprof_raw_monitor_t *rmon;
    JNIEnv *env_id;

    SANITY_CHECK("hprof_raw_monitor_event");
    cur_time = CALL(GetCurrentThreadCpuTime)();
    hname = hprof_intern_name(name);
    rmon = hprof_intern_raw_monitor(mid, hname);
    env_id = event->env_id;

    CALL(RawMonitorEnter)(data_access_lock);
    
    if (output_format == 'a') {
    	switch(event->event_type) {
	case JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTER: 
	    hprof_contended_monitor_enter(JVMPI_MONITOR_RAW, rmon,
					  env_id, cur_time);
	    break;
	case JVMPI_EVENT_RAW_MONITOR_CONTENDED_ENTERED: 
	    hprof_contended_monitor_entered(JVMPI_MONITOR_RAW, rmon,
					    env_id, cur_time);
	    break;
	}
    }
    
    CALL(RawMonitorExit)(data_access_lock);
}

void hprof_monitor_event(JVMPI_Event *event, jobjectID obj)
{
    jlong cur_time;
    JNIEnv *env_id;
    hprof_objmap_t *objmap; 

    SANITY_CHECK("hprof_monitor_event");
    cur_time = CALL(GetCurrentThreadCpuTime)();
    env_id = event->env_id;

    if (obj == NULL) {
        return;
    }

    CALL(RawMonitorEnter)(data_access_lock);
    
    objmap = hprof_fetch_object_info(obj);
    if (objmap == NULL) {
        fprintf(stderr, "HPROF ERROR: unknown object ID 0x%p\n", obj);
    }
        
    if (output_format == 'a') {
        switch (event->event_type) {
	case JVMPI_EVENT_MONITOR_CONTENDED_ENTER:
	    hprof_contended_monitor_enter(JVMPI_MONITOR_JAVA, objmap,
					  env_id, cur_time);
	    break;
	case JVMPI_EVENT_MONITOR_CONTENDED_ENTERED:
	    hprof_contended_monitor_entered(JVMPI_MONITOR_JAVA, objmap,
					  env_id, cur_time);
	    break;
	}
    }
    
    CALL(RawMonitorExit)(data_access_lock);
}

void hprof_monitor_wait_event(JVMPI_Event *event, jobjectID obj,
			      jlong timeout)
{
    SANITY_CHECK("hprof_monitor_wait_event");
    CALL(RawMonitorEnter)(data_access_lock);
    if (output_format == 'a') {
	hprof_fetch_thread_info(event->env_id);
        if (obj == NULL) {
	    hprof_printf("SLEEP:");
	    hprof_printf(" timeout=%d,", timeout);
	    hprof_print_thread_info(event->env_id, FALSE);
	    hprof_printf("\n");
	    goto done;
	}
	hprof_printf("WAIT: MONITOR");
	hprof_print_object_info(obj);
	hprof_printf(", timeout=%d,", timeout);
	hprof_print_thread_info(event->env_id, FALSE);
	hprof_printf("\n");
    }
 done:
    CALL(RawMonitorExit)(data_access_lock);
}

void hprof_dump_monitors(void)
{
    SANITY_CHECK("hprof_dump_monitors");
    CALL(RequestEvent)(JVMPI_EVENT_MONITOR_DUMP, NULL);
}

void hprof_monitor_dump_event(JVMPI_Event *event)
{
    int i;
    hprof_trace_t **traces = NULL;

    SANITY_CHECK("hprof_monitor_dump_event");
    CALL(RawMonitorEnter)(data_access_lock);
    if (event->u.monitor_dump.num_traces) {
        traces = HPROF_CALLOC(ALLOC_TYPE_ARRAY,
	    event->u.monitor_dump.num_traces * sizeof(void *));
    }

    for (i = 0; i < event->u.monitor_dump.num_traces; i++) {
        JVMPI_CallTrace *jtrace = &(event->u.monitor_dump.traces[i]);
	traces[i] = hprof_intern_jvmpi_trace(jtrace->frames,
					     jtrace->num_frames,
					     jtrace->env_id);
    }
    hprof_output_unmarked_traces();

    if (output_format == 'a') {
        hprof_dump_seek(event->u.monitor_dump.begin);
	while(hprof_dump_cur() < event->u.monitor_dump.end) {
	    int kind = hprof_dump_read_u1();
	    int n;
	    JNIEnv *thread_env;
	    if (kind == JVMPI_MONITOR_JAVA) {
                hprof_dump_read_id();
	    } else if (kind == JVMPI_MONITOR_RAW) {
	        hprof_dump_read_id();
		hprof_dump_read_id();
	    } else {
	        fprintf(stderr, "HPROF ERROR: bad monitor kind: %d\n", kind);
	    }
	    thread_env = hprof_dump_read_id();
	    if (thread_env) {
	        hprof_fetch_thread_info(thread_env);
	    }
	    hprof_dump_read_u4();
	    n = hprof_dump_read_u4();
	    for (i = 0; i < n; i++) {
	        thread_env = hprof_dump_read_id();
		hprof_fetch_thread_info(thread_env);
	    }
	    n = hprof_dump_read_u4();
	    for (i = 0; i < n; i++) {
	        thread_env = hprof_dump_read_id();
		hprof_fetch_thread_info(thread_env);
	    }
	}
        hprof_printf("MONITOR DUMP BEGIN\n");
	for (i = 0; i < event->u.monitor_dump.num_traces; i++) {
	    JVMPI_CallTrace *jtrace = &(event->u.monitor_dump.traces[i]);
	    hprof_thread_t *thread = hprof_lookup_thread(jtrace->env_id);
	    int status = event->u.monitor_dump.threads_status[i];
	    hprof_printf("    THREAD %d, trace %d, status: ",
			 thread->serial_num,
			 traces[i]->serial_num);
	    if (status & JVMPI_THREAD_SUSPENDED) {
	        hprof_printf("S|");
		status &= ~JVMPI_THREAD_SUSPENDED;
	    }
	    if (status & JVMPI_THREAD_INTERRUPTED) {
	        hprof_printf("intr|");
		status &= ~JVMPI_THREAD_INTERRUPTED;
	    }
	    switch (status) {
	    case JVMPI_THREAD_RUNNABLE:
	        hprof_printf("R");
		break;
	    case JVMPI_THREAD_MONITOR_WAIT:
	        hprof_printf("MW");
		break;
	    case JVMPI_THREAD_CONDVAR_WAIT:
	        hprof_printf("CW");
		break;
	    }
	    hprof_printf("\n");
	}
        hprof_dump_seek(event->u.monitor_dump.begin);
	while(hprof_dump_cur() < event->u.monitor_dump.end) {
	    int kind = hprof_dump_read_u1();
	    void *owner;
	    int entry_count;
	    int n;
	    if (kind == JVMPI_MONITOR_JAVA) {
	        jobjectID obj = hprof_dump_read_id();
	        hprof_printf("    MONITOR");
		hprof_print_object_info(obj);
	    } else if (kind == JVMPI_MONITOR_RAW) {
	        char *name = hprof_dump_read_id();
		JVMPI_RawMonitor mid = hprof_dump_read_id();
	        hprof_printf("    RAW MONITOR");
		hprof_printf(" \"%s\"(0x%x)", name, mid);
	    } else {
	        fprintf(stderr, "HPROF ERROR: bad monitor kind: %d\n", kind);
	    }
	    owner = hprof_dump_read_id();
	    entry_count = hprof_dump_read_u4();
	    if (owner) {
	        hprof_printf("\n\towner:");
		hprof_print_thread_info(owner, FALSE);
		hprof_printf(", entry count: %d", entry_count);
	    } else {
	        hprof_printf(" unowned");
	    }
	    n = hprof_dump_read_u4();
	    if (n > 0) {
	        hprof_printf("\n\twaiting to enter:");
		for (i = 0; i < n; i++) {
		    void *thr = hprof_dump_read_id();
		    hprof_print_thread_info(thr, i > 0);
		}
	    }
	    n = hprof_dump_read_u4();
	    if (n > 0) {
	        hprof_printf("\n\twaiting to be notified:");
	        for (i = 0; i < n; i++) {
		    void *thr = hprof_dump_read_id();
		    hprof_print_thread_info(thr, i > 0);
		}
	    }
	    hprof_printf("\n");
	}
	hprof_printf("MONITOR DUMP END\n");
    }
    if (traces != NULL) hprof_free(traces);
    CALL(RawMonitorExit)(data_access_lock);
}


#ifdef HASH_STATS
void hprof_print_contended_monitor_hash_stats(FILE *fp) {
    SANITY_CHECK("hprof_print_contended_monitor_hash_stats");
    hprof_print_tbl_hash_stats(fp, &hprof_contended_monitor_table);
}


void hprof_print_raw_monitor_hash_stats(FILE *fp) {
    SANITY_CHECK("hprof_print_raw_monitor_hash_stats");
    hprof_print_tbl_hash_stats(fp, &hprof_raw_monitor_table);
}
#endif /* HASH_STATS */


#ifdef WATCH_ALLOCS
void hprof_free_contended_monitor_table(void)
{
    SANITY_CHECK("hprof_free_contended_monitor_table");
    hprof_hash_removeall(&hprof_contended_monitor_table);
    hprof_hash_free(&hprof_contended_monitor_table);
}


void hprof_free_raw_monitor_table(void)
{
    SANITY_CHECK("hprof_free_raw_monitor_table");
    hprof_hash_removeall(&hprof_raw_monitor_table);
    hprof_hash_free(&hprof_raw_monitor_table);
}
#endif /* WATCH_ALLOCS */