hprof_io.c

来自「一个小公司要求给写的很简单的任务管理系统。」· C语言 代码 · 共 1,979 行 · 第 1/4 页

            
            /* Send out segment (up to last tag written out) */
            dump_heap_segment_and_reset(gdata->heap_last_tag_position);

	    /* Get new current position */
            pos = gdata->heap_write_count + (jlong)gdata->heap_buffer_index;
	}
    }
    /* Save position of this tag */
    gdata->heap_last_tag_position = pos;
    /* Write out this tag */
    heap_u1(tag);
}

static void
heap_id(HprofId i)
{
    heap_u4(i);
}

static void
heap_index_id(HprofId index)
{
    heap_id(index);
}

static void
heap_name(char *name)
{
    heap_index_id(get_name_index(name));
}

static void 
heap_printf(char *fmt, ...)
{
    char buf[1024];
    va_list args;
    va_start(args, fmt);
    (void)md_vsnprintf(buf, sizeof(buf), fmt, args);
    buf[sizeof(buf)-1] = 0;
    heap_raw(buf, (int)strlen(buf));
    va_end(args);
}

static void
heap_element(HprofType kind, jint size, jvalue value)
{
    if ( !HPROF_TYPE_IS_PRIMITIVE(kind) ) {
	HPROF_ASSERT(size==4);
	heap_id((HprofId)value.i);
    } else {
	switch ( size ) {
	    case 8:
	        HPROF_ASSERT(size==8);
	        HPROF_ASSERT(kind==HPROF_LONG || kind==HPROF_DOUBLE);
		heap_u8(value.j);
		break;
	    case 4:
	        HPROF_ASSERT(size==4);
	        HPROF_ASSERT(kind==HPROF_INT || kind==HPROF_FLOAT);
		heap_u4(value.i);
		break;
	    case 2:
	        HPROF_ASSERT(size==2);
	        HPROF_ASSERT(kind==HPROF_SHORT || kind==HPROF_CHAR);
		heap_u2(value.s);
		break;
	    case 1:
	        HPROF_ASSERT(size==1);
	        HPROF_ASSERT(kind==HPROF_BOOLEAN || kind==HPROF_BYTE);
		HPROF_ASSERT(kind==HPROF_BOOLEAN?(value.b==0 || value.b==1):1);
		heap_u1(value.b);
		break;
	    default:
		HPROF_ASSERT(0);
		break;
	}
    }
}

/* Dump out all elements of an array, objects in jvalues, prims packed */
static void
heap_elements(HprofType kind, jint num_elements, jint elem_size, void *elements)
{
    int     i;
    jvalue  val;
    static jvalue empty_val;

    if ( num_elements == 0 ) {
	return;
    }

    switch ( kind ) {
	case 0:
	case HPROF_ARRAY_OBJECT: 
	case HPROF_NORMAL_OBJECT: 
	    for (i = 0; i < num_elements; i++) {  
		val   = empty_val;
		val.i = ((ObjectIndex*)elements)[i];
		heap_element(kind, elem_size, val);
	    }
	    break;
	case HPROF_BYTE: 
	case HPROF_BOOLEAN:
	    HPROF_ASSERT(elem_size==1);
	    for (i = 0; i < num_elements; i++) {  
		val   = empty_val;
		val.b = ((jboolean*)elements)[i];
		heap_element(kind, elem_size, val);
	    }
	    break;
	case HPROF_CHAR: 
	case HPROF_SHORT:
	    HPROF_ASSERT(elem_size==2);
	    for (i = 0; i < num_elements; i++) {  
		val   = empty_val;
		val.s = ((jshort*)elements)[i];
		heap_element(kind, elem_size, val);
	    }
	    break;
	case HPROF_FLOAT: 
	case HPROF_INT:
	    HPROF_ASSERT(elem_size==4);
	    for (i = 0; i < num_elements; i++) {  
		val   = empty_val;
		val.i = ((jint*)elements)[i];
		heap_element(kind, elem_size, val);
	    }
	    break;
	case HPROF_DOUBLE: 
	case HPROF_LONG:
	    HPROF_ASSERT(elem_size==8);
	    for (i = 0; i < num_elements; i++) {  
		val   = empty_val;
		val.j = ((jlong*)elements)[i];
		heap_element(kind, elem_size, val);
	    }
	    break;
    }
}

/* ------------------------------------------------------------------ */

void 
io_flush(void)
{
    HPROF_ASSERT(gdata->header!=NULL);
    write_flush();
}

void 
io_setup(void)
{
    gdata->write_buffer_size = FILE_IO_BUFFER_SIZE;
    gdata->write_buffer = HPROF_MALLOC(gdata->write_buffer_size);
    gdata->write_buffer_index = 0;
    
    gdata->heap_write_count = (jlong)0;
    gdata->heap_last_tag_position = (jlong)0;
    gdata->heap_buffer_size = FILE_IO_BUFFER_SIZE;
    gdata->heap_buffer = HPROF_MALLOC(gdata->heap_buffer_size);
    gdata->heap_buffer_index = 0;
    
    if ( gdata->logflags & LOG_CHECK_BINARY ) {
	gdata->check_buffer_size = FILE_IO_BUFFER_SIZE;
	gdata->check_buffer = HPROF_MALLOC(gdata->check_buffer_size);
	gdata->check_buffer_index = 0;
    }

    ioname_init();
}

void 
io_cleanup(void)
{
    if ( gdata->write_buffer != NULL ) {
	HPROF_FREE(gdata->write_buffer);
    }
    gdata->write_buffer_size = 0;
    gdata->write_buffer = NULL;
    gdata->write_buffer_index = 0;
    
    if ( gdata->heap_buffer != NULL ) {
	HPROF_FREE(gdata->heap_buffer);
    }
    gdata->heap_write_count = (jlong)0;
    gdata->heap_last_tag_position = (jlong)0;
    gdata->heap_buffer_size = 0;
    gdata->heap_buffer = NULL;
    gdata->heap_buffer_index = 0;
    
    if ( gdata->logflags & LOG_CHECK_BINARY ) {
	if ( gdata->check_buffer != NULL ) {
	    HPROF_FREE(gdata->check_buffer);
	}
	gdata->check_buffer_size = 0;
	gdata->check_buffer = NULL;
	gdata->check_buffer_index = 0;
    }

    ioname_cleanup();
}

void
io_write_file_header(void)
{
    HPROF_ASSERT(gdata->header!=NULL);
    if (gdata->output_format == 'b') {
        jint settings;
        jlong t;
        
        settings = 0;
        if (gdata->heap_dump || gdata->alloc_sites) {
            settings |= 1;
        }
        if (gdata->cpu_sampling) {
            settings |= 2;
        }
        t = md_get_timemillis();
        
        write_raw(gdata->header, (int)strlen(gdata->header) + 1);
        write_u4((jint)sizeof(HprofId));
        write_u8(t);
        
        write_header(HPROF_CONTROL_SETTINGS, 4 + 2);
        write_u4(settings);
        write_u2((unsigned short)gdata->max_trace_depth);
    
    } else if ((!gdata->cpu_timing) || (!gdata->old_timing_format)) {
	/* We don't want the prelude file for the old prof output format */
	time_t t;
	char prelude_file[FILENAME_MAX];
	int prelude_fd;
	int nbytes;
	
	t = time(0);

	md_get_prelude_path(prelude_file, sizeof(prelude_file), PRELUDE_FILE);

	prelude_fd = md_open(prelude_file);
	if (prelude_fd < 0) {
	    char buf[FILENAME_MAX+80];
	    
	    (void)md_snprintf(buf, sizeof(buf), "Can't open %s", prelude_file);
	    buf[sizeof(buf)-1] = 0;
	    HPROF_ERROR(JNI_TRUE, buf);
	}
	
	write_printf("%s, created %s\n", gdata->header, ctime(&t));
	
	do {
	    char buf[1024]; /* File is small, small buffer ok here */
	    
	    nbytes = md_read(prelude_fd, buf, sizeof(buf));
	    if ( nbytes < 0 ) {
		system_error("read", nbytes, errno);
		break;
	    }
	    if (nbytes == 0) {
		break;
	    }
	    write_raw(buf, nbytes);
	} while ( nbytes > 0 );

	md_close(prelude_fd);
	
	write_printf("\n--------\n\n");
	
	write_flush();
    }
}

void
io_write_file_footer(void)
{
    HPROF_ASSERT(gdata->header!=NULL);
}

void
io_write_class_load(SerialNumber class_serial_num, ObjectIndex index,
		    SerialNumber trace_serial_num, char *sig)
{
    CHECK_CLASS_SERIAL_NO(class_serial_num);
    CHECK_TRACE_SERIAL_NO(trace_serial_num);
    if (gdata->output_format == 'b') {
        IoNameIndex name_index;
	char *class_name;

	class_name = signature_to_name(sig);
        name_index = write_name_first(class_name);
        write_header(HPROF_LOAD_CLASS, (2 * (jint)sizeof(HprofId)) + (4 * 2));
        write_u4(class_serial_num);
        write_index_id(index);
        write_u4(trace_serial_num);
        write_index_id(name_index);
	HPROF_FREE(class_name);    
    }
}

void
io_write_class_unload(SerialNumber class_serial_num, ObjectIndex index)
{
    CHECK_CLASS_SERIAL_NO(class_serial_num);
    if (gdata->output_format == 'b') {
        write_header(HPROF_UNLOAD_CLASS, 4);
        write_u4(class_serial_num);
    }
}

void
io_write_sites_header(const char * comment_str, jint flags, double cutoff,
		    jint total_live_bytes, jint total_live_instances,
		    jlong total_alloced_bytes, jlong total_alloced_instances,
		    jint count)
{
    if ( gdata->output_format == 'b') {
        write_header(HPROF_ALLOC_SITES, 2 + (8 * 4) + (count * (4 * 6 + 1)));
        write_u2((unsigned short)flags);
	write_u4(*(int *)(&cutoff));
        write_u4(total_live_bytes);
        write_u4(total_live_instances);
        write_u8(total_alloced_bytes);
        write_u8(total_alloced_instances);
        write_u4(count);
    } else {
        time_t t;

        t = time(0);
        write_printf("SITES BEGIN (ordered by %s) %s", comment_str, ctime(&t));
        write_printf(
            "          percent          live          alloc'ed  stack class\n");
        write_printf(
            " rank   self  accum     bytes objs     bytes  objs trace name\n");
    }
}

void
io_write_sites_elem(jint index, double ratio, double accum_percent,
		char *sig, SerialNumber class_serial_num,
		SerialNumber trace_serial_num, jint n_live_bytes,
		jint n_live_instances, jint n_alloced_bytes,
		jint n_alloced_instances)
{
    CHECK_CLASS_SERIAL_NO(class_serial_num);
    CHECK_TRACE_SERIAL_NO(trace_serial_num);
    if ( gdata->output_format == 'b') {
        HprofType kind;
	jint size;
	
	type_array(sig, &kind, &size);
	write_u1(kind);
        write_u4(class_serial_num);
        write_u4(trace_serial_num);
        write_u4(n_live_bytes);
        write_u4(n_live_instances);
        write_u4(n_alloced_bytes);
        write_u4(n_alloced_instances);
    } else {
	char *class_name;

	class_name = signature_to_name(sig);
        write_printf("%5u %5.2f%% %5.2f%% %9u %4u %9u %5u %5u %s\n",
                     index,
                     ratio * 100.0,
                     accum_percent * 100.0,
                     n_live_bytes,
                     n_live_instances,
                     n_alloced_bytes,
                     n_alloced_instances,
                     trace_serial_num,
                     class_name);
	HPROF_FREE(class_name);    
    }
}

void
io_write_sites_footer(void)
{
    if (gdata->output_format == 'b') {
        not_implemented();
    } else {
        write_printf("SITES END\n");
    }
}

void
io_write_thread_start(SerialNumber thread_serial_num, 
			ObjectIndex thread_obj_id,
			SerialNumber trace_serial_num, char *thread_name,
			char *thread_group_name, char *thread_parent_name)
{
    CHECK_THREAD_SERIAL_NO(thread_serial_num);
    CHECK_TRACE_SERIAL_NO(trace_serial_num);
    if (gdata->output_format == 'b') {
        IoNameIndex tname_index;
        IoNameIndex gname_index;
        IoNameIndex pname_index;
        
        tname_index = write_name_first(thread_name);
        gname_index = write_name_first(thread_group_name);
        pname_index = write_name_first(thread_parent_name);
        write_header(HPROF_START_THREAD, ((jint)sizeof(HprofId) * 4) + (4 * 2));
        write_u4(thread_serial_num);
        write_index_id(thread_obj_id);
        write_u4(trace_serial_num);
        write_index_id(tname_index);
        write_index_id(gname_index);
        write_index_id(pname_index);
    
    } else if ( (!gdata->cpu_timing) || (!gdata->old_timing_format)) {
	/* We don't want thread info for the old prof output format */
	write_printf("THREAD START "
		     "(obj=%x, id = %d, name=\"%s\", group=\"%s\")\n",
		     thread_obj_id, thread_serial_num,
		     (thread_name==NULL?"":thread_name), 
		     (thread_group_name==NULL?"":thread_group_name));
    }
}

void
io_write_thread_end(SerialNumber thread_serial_num)
{
    CHECK_THREAD_SERIAL_NO(thread_serial_num);
    if (gdata->output_format == 'b') {
        write_header(HPROF_END_THREAD, 4);
        write_u4(thread_serial_num);
    
    } else if ( (!gdata->cpu_timing) || (!gdata->old_timing_format)) {
	/* we don't want thread info for the old prof output format */
	write_printf("THREAD END (id = %d)\n", thread_serial_num);
    }
}

void
io_write_frame(FrameIndex index, SerialNumber frame_serial_num,
	       char *mname, char *msig, char *sname,
	       SerialNumber class_serial_num, jint lineno)
{
    CHECK_CLASS_SERIAL_NO(class_serial_num);
    if (gdata->output_format == 'b') {
        IoNameIndex mname_index;
        IoNameIndex msig_index;
        IoNameIndex sname_index;
        
        mname_index = write_name_first(mname);
        msig_index  = write_name_first(msig);
        sname_index = write_name_first(sname);

        write_header(HPROF_FRAME, ((jint)sizeof(HprofId) * 4) + (4 * 2));
        write_index_id(index);
        write_index_id(mname_index);
        write_index_id(msig_index);
        write_index_id(sname_index);
        write_u4(class_serial_num);
        write_u4(lineno);
    }
}

void
io_write_trace_header(SerialNumber trace_serial_num, 
		SerialNumber thread_serial_num, jint n_frames, char *phase_str)
{
    CHECK_TRACE_SERIAL_NO(trace_serial_num);
    if (gdata->output_format == 'b') {
        write_header(HPROF_TRACE, ((jint)sizeof(HprofId) * n_frames) + (4 * 3));
        write_u4(trace_serial_num);
        write_u4(thread_serial_num);
        write_u4(n_frames);
    } else {
        write_printf("TRACE %u:", trace_serial_num);
        if (thread_serial_num) {
            write_printf(" (thread=%d)", thread_serial_num);
        }
        if ( phase_str != NULL ) {
	    write_printf(" (from %s phase of JVM)", phase_str);
	}
        write_printf("\n");
        if (n_frames == 0) {
            write_printf("\t<empty>\n");
        }
    }
}

void
io_write_trace_elem(SerialNumber trace_serial_num, FrameIndex frame_index, 
		    SerialNumber frame_serial_num,
		    char *csig, char *mname, char *sname, jint lineno)
{
    if (gdata->output_format == 'b') {
        write_index_id(frame_index);
    } else {
	char *class_name;
        char linebuf[32];

        if (lineno == -2) {