1 /* -----------------------------------------------------------------------------
2 * $Id: FrontPanel.c,v 1.2 2000/11/01 11:57:29 simonmar Exp $
4 * (c) The GHC Team 2000
8 * ---------------------------------------------------------------------------*/
10 #ifdef RTS_GTK_FRONTPANEL
12 #define NON_POSIX_SOURCE
17 #include "FrontPanel.h"
18 #include "StoragePriv.h"
24 #include <gdk/gdktypes.h>
27 #include "VisSupport.h"
28 #include "VisWindow.h"
30 static GtkWidget *window, *map_drawing_area, *gen_drawing_area;
31 static GtkWidget *res_drawing_area;
32 static GtkWidget *continue_but, *stop_but, *quit_but;
33 static GtkWidget *statusbar;
34 static GtkWidget *live_label, *allocated_label;
35 static GtkWidget *footprint_label, *alloc_rate_label;
36 static GtkWidget *map_ruler, *gen_ruler;
37 static GtkWidget *res_vruler, *res_hruler;
38 static GtkWidget *running_label, *b_read_label, *b_write_label, *total_label;
39 static GtkWidget *b_mvar_label, *b_bh_label, *b_throwto_label, *sleeping_label;
41 static guint status_context_id;
43 gboolean continue_now = FALSE, stop_now = FALSE, quit = FALSE;
44 UpdateMode update_mode = Continuous;
46 static GdkPixmap *map_pixmap = NULL;
47 static GdkPixmap *gen_pixmap = NULL;
48 static GdkPixmap *res_pixmap = NULL;
53 bdescr_color = { 0, 0xffff, 0, 0 }, /* red */
54 free_color = { 0, 0, 0, 0xffff }, /* blue */
55 gen_colors[N_GENS] = {
70 static void *mem_start = (void *) 0x50000000;
72 static void colorBlock( void *addr, GdkColor *color,
73 nat block_width, nat block_height,
74 nat blocks_per_line );
76 static void residencyCensus( void );
77 static void updateResidencyGraph( void );
78 static void updateThreadsPanel( void );
80 /* Some code pinched from examples/scribble-simple in the GTK+
84 /* Create a new backing pixmap of the appropriate size */
86 configure_event( GtkWidget *widget, GdkEventConfigure *event STG_UNUSED,
90 gdk_pixmap_unref(*pixmap);
92 *pixmap = gdk_pixmap_new(widget->window,
93 widget->allocation.width,
94 widget->allocation.height,
97 gdk_draw_rectangle (*pixmap,
98 widget->style->white_gc,
101 widget->allocation.width,
102 widget->allocation.height);
104 fprintf(stderr, "configure!\n");
109 /* Redraw the screen from the backing pixmap */
111 expose_event( GtkWidget *widget, GdkEventExpose *event, GdkPixmap **pixmap )
113 gdk_draw_pixmap(widget->window,
114 widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
116 event->area.x, event->area.y,
117 event->area.x, event->area.y,
118 event->area.width, event->area.height);
124 initFrontPanel( void )
126 GdkColormap *colormap;
129 gtk_init( &prog_argc, &prog_argv );
131 window = create_GHC_Front_Panel();
132 map_drawing_area = lookup_widget(window, "memmap");
133 gen_drawing_area = lookup_widget(window, "generations");
134 res_drawing_area = lookup_widget(window, "res_drawingarea");
135 stop_but = lookup_widget(window, "stop_but");
136 continue_but = lookup_widget(window, "continue_but");
137 quit_but = lookup_widget(window, "quit_but");
138 statusbar = lookup_widget(window, "statusbar");
139 live_label = lookup_widget(window, "live_label");
140 footprint_label = lookup_widget(window, "footprint_label");
141 allocated_label = lookup_widget(window, "allocated_label");
142 alloc_rate_label = lookup_widget(window, "alloc_rate_label");
143 gen_hbox = lookup_widget(window, "gen_hbox");
144 gen_ruler = lookup_widget(window, "gen_ruler");
145 map_ruler = lookup_widget(window, "map_ruler");
146 res_vruler = lookup_widget(window, "res_vruler");
147 res_hruler = lookup_widget(window, "res_hruler");
148 running_label = lookup_widget(window, "running_label");
149 b_read_label = lookup_widget(window, "blockread_label");
150 b_write_label = lookup_widget(window, "blockwrite_label");
151 b_mvar_label = lookup_widget(window, "blockmvar_label");
152 b_bh_label = lookup_widget(window, "blockbh_label");
153 b_throwto_label = lookup_widget(window, "blockthrowto_label");
154 sleeping_label = lookup_widget(window, "sleeping_label");
155 total_label = lookup_widget(window, "total_label");
158 gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "context" );
160 /* hook up some signals for the mem map drawing area */
161 gtk_signal_connect (GTK_OBJECT(map_drawing_area), "expose_event",
162 (GtkSignalFunc)expose_event, &map_pixmap);
163 gtk_signal_connect (GTK_OBJECT(map_drawing_area), "configure_event",
164 (GtkSignalFunc)configure_event, &map_pixmap);
166 gtk_widget_set_events(map_drawing_area, GDK_EXPOSURE_MASK);
168 /* hook up some signals for the gen drawing area */
169 gtk_signal_connect (GTK_OBJECT(gen_drawing_area), "expose_event",
170 (GtkSignalFunc)expose_event, &gen_pixmap);
171 gtk_signal_connect (GTK_OBJECT(gen_drawing_area), "configure_event",
172 (GtkSignalFunc)configure_event, &gen_pixmap);
174 gtk_widget_set_events(gen_drawing_area, GDK_EXPOSURE_MASK);
176 /* hook up some signals for the res drawing area */
177 gtk_signal_connect (GTK_OBJECT(res_drawing_area), "expose_event",
178 (GtkSignalFunc)expose_event, &res_pixmap);
179 gtk_signal_connect (GTK_OBJECT(res_drawing_area), "configure_event",
180 (GtkSignalFunc)configure_event, &res_pixmap);
182 gtk_widget_set_events(res_drawing_area, GDK_EXPOSURE_MASK);
184 /* allocate our colors */
185 colormap = gdk_colormap_get_system();
186 gdk_colormap_alloc_color(colormap, &bdescr_color, TRUE, TRUE);
187 gdk_colormap_alloc_color(colormap, &free_color, TRUE, TRUE);
190 gboolean success[N_GENS];
191 gdk_colormap_alloc_colors(colormap, gen_colors, N_GENS, TRUE,
193 if (!success) { barf("can't allocate colors"); }
196 /* set the labels on the generation histogram */
202 for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
203 for(s = 0; s < generations[g].n_steps; s++) {
204 g_snprintf( buf, 64, "%d.%d", g, s );
205 label = gtk_label_new( buf );
206 gtk_box_pack_start( GTK_BOX(gen_hbox), label,
208 gtk_widget_show(label);
213 gtk_widget_show(window);
215 /* wait for the user to press "Continue" before getting going... */
216 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id,
218 gtk_widget_set_sensitive( stop_but, FALSE );
219 continue_now = FALSE;
220 while (continue_now == FALSE) {
221 gtk_main_iteration();
223 gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
224 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id,
227 gtk_widget_set_sensitive( continue_but, FALSE );
228 gtk_widget_set_sensitive( stop_but, TRUE );
229 gtk_widget_set_sensitive( quit_but, FALSE );
231 while (gtk_events_pending()) {
232 gtk_main_iteration();
237 stopFrontPanel( void )
239 gtk_widget_set_sensitive( quit_but, TRUE );
240 gtk_widget_set_sensitive( continue_but, FALSE );
241 gtk_widget_set_sensitive( stop_but, FALSE );
245 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id,
249 while (quit == FALSE) {
250 gtk_main_iteration();
255 waitForContinue( void )
257 gtk_widget_set_sensitive( continue_but, TRUE );
258 gtk_widget_set_sensitive( stop_but, FALSE );
260 continue_now = FALSE;
261 while (continue_now == FALSE) {
262 gtk_main_iteration();
264 gtk_widget_set_sensitive( continue_but, FALSE );
265 gtk_widget_set_sensitive( stop_but, TRUE );
269 updateFrontPanelBeforeGC( nat N )
275 if (update_mode == BeforeGC
276 || update_mode == BeforeAfterGC
277 || stop_now == TRUE) {
278 g_snprintf( buf, 1000, "Stopped (before GC, generation %d)", N );
279 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, buf );
281 gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
284 g_snprintf( buf, 1000, "Garbage collecting (generation %d)", N );
285 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, buf);
287 while (gtk_events_pending()) {
288 gtk_main_iteration();
293 numLabel( GtkWidget *lbl, nat n )
296 g_snprintf(buf, 64, "%d", n);
297 gtk_label_set_text( GTK_LABEL(lbl), buf );
301 updateFrontPanelAfterGC( nat N, lnat live )
305 gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
308 if (N == RtsFlags.GcFlags.generations-1) {
314 if (update_mode == AfterGC
315 || update_mode == BeforeAfterGC
316 || stop_now == TRUE) {
317 snprintf( buf, 1000, "Stopped (after GC, generation %d)", N );
318 gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, buf );
320 gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
324 double words_to_megs = (1024 * 1024) / sizeof(W_);
325 double time = mut_user_time();
327 snprintf( buf, 1000, "%.2f", (double)live / words_to_megs );
328 gtk_label_set_text( GTK_LABEL(live_label), buf );
330 snprintf( buf, 1000, "%.2f", (double)total_allocated / words_to_megs );
331 gtk_label_set_text( GTK_LABEL(allocated_label), buf );
333 snprintf( buf, 1000, "%.2f",
334 (double)(mblocks_allocated * MBLOCK_SIZE_W) / words_to_megs );
335 gtk_label_set_text( GTK_LABEL(footprint_label), buf );
338 snprintf( buf, 1000, "%.2f", time );
340 snprintf( buf, 1000, "%.2f",
341 (double)(total_allocated / words_to_megs) / time );
342 gtk_label_set_text( GTK_LABEL(alloc_rate_label), buf );
345 while (gtk_events_pending()) {
346 gtk_main_iteration();
351 updateFrontPanel( void )
356 updateThreadsPanel();
359 my_gc = gdk_gc_new( window->window );
362 if (map_pixmap != NULL) {
363 nat height, width, blocks_per_line,
364 block_height, block_width, mblock_height;
366 height = map_drawing_area->allocation.height;
367 width = map_drawing_area->allocation.width;
369 mblock_height = height / mblocks_allocated;
370 blocks_per_line = 16;
371 block_height = mblock_height /
372 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
373 while (block_height == 0) {
374 blocks_per_line *= 2;
375 block_height = mblock_height /
376 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
378 block_width = width / blocks_per_line;
380 gdk_draw_rectangle (map_pixmap,
381 map_drawing_area->style->bg_gc[GTK_STATE_NORMAL],
384 map_drawing_area->allocation.width,
385 map_drawing_area->allocation.height);
388 (char *)m < (char *)mem_start +
389 (mblocks_allocated * MBLOCK_SIZE);
390 (char *)m += MBLOCK_SIZE ) {
392 /* color the bdescr area first */
393 for (a = m; a < FIRST_BLOCK(m); (char *)a += BLOCK_SIZE) {
394 colorBlock( a, &bdescr_color,
395 block_width, block_height, blocks_per_line );
398 /* color each block */
399 for (; a <= LAST_BLOCK(m); (char *)a += BLOCK_SIZE) {
401 ASSERT(bd->start == a);
402 if (bd->free == (void *)-1) {
403 colorBlock( a, &free_color,
404 block_width, block_height, blocks_per_line );
405 } else if (bd->gen != NULL) {
406 colorBlock( a, &gen_colors[bd->gen->no],
407 block_width, block_height, blocks_per_line );
408 } else if (bd->link != NULL) {
409 if (bd->link->free == (void *)-1) {
410 colorBlock( a, &free_color,
411 block_width, block_height, blocks_per_line );
413 } else if (bd->link->gen != NULL) {
414 colorBlock( a, &gen_colors[bd->link->gen->no],
415 block_width, block_height, blocks_per_line );
417 belch("block at %p: can't indentify", bd->start);
425 nat height = map_drawing_area->allocation.height,
426 block_height, mblock_height;
428 block_height = (height / mblocks_allocated) /
429 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
430 if (block_height < 1) block_height = 1;
431 mblock_height = block_height *
432 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
434 gtk_ruler_set_range( GTK_RULER(map_ruler), 0,
435 (double)(height * mblocks_allocated) /
436 (double)((mblock_height * mblocks_allocated)),
438 (double)(height * mblocks_allocated) /
439 (double)((mblock_height * mblocks_allocated))
443 gtk_widget_draw( map_drawing_area, NULL );
446 if (gen_pixmap != NULL) {
449 nat g, s, columns, column, max_blocks, height_blocks,
452 gdk_draw_rectangle (gen_pixmap,
453 gen_drawing_area->style->white_gc,
456 gen_drawing_area->allocation.width,
457 gen_drawing_area->allocation.height);
459 height = gen_drawing_area->allocation.height;
460 width = gen_drawing_area->allocation.width;
462 columns = 0; max_blocks = 0;
463 for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
464 columns += generations[g].n_steps;
465 for(s = 0; s < generations[g].n_steps; s++) {
466 if (generations[g].steps[s].n_blocks > max_blocks) {
467 max_blocks = generations[g].steps[s].n_blocks;
472 /* find a reasonable height value larger than max_blocks */
475 while (max_blocks != 0) {
476 max_blocks >>= 1; n++;
478 height_blocks = 1 << n;
482 for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
483 for(s = 0; s < generations[g].n_steps; s++, column++) {
484 gdk_gc_set_foreground(my_gc, &gen_colors[g]);
486 rect.x = column * (width / columns);
488 if (generations[g].steps[s].n_blocks == 0)
492 (height * generations[g].steps[s].n_blocks
495 rect.width = (width / columns);
496 rect.height = height - rect.y;
498 gdk_draw_rectangle( gen_pixmap, my_gc, TRUE/*filled*/,
499 rect.x, rect.y, rect.width,
504 gtk_ruler_set_range( GTK_RULER(gen_ruler),
505 height_blocks * BLOCK_SIZE / (1024 * 1024),
507 height_blocks * BLOCK_SIZE / (1024 * 1024)
510 gtk_widget_draw( gen_drawing_area, NULL );
513 if (res_pixmap != NULL) {
514 updateResidencyGraph();
517 while (gtk_events_pending()) {
518 gtk_main_iteration_do(FALSE/*don't block*/);
523 colorBlock( void *addr, GdkColor *color,
524 nat block_width, nat block_height, nat blocks_per_line )
529 gdk_gc_set_foreground(my_gc, color);
531 block_no = ((char *)addr - (char *)mem_start) / BLOCK_SIZE;
533 rect.x = (block_no % blocks_per_line) * block_width;
534 rect.y = block_no / blocks_per_line * block_height;
535 rect.width = block_width;
536 rect.height = block_height;
537 gdk_draw_rectangle( map_pixmap, my_gc, TRUE/*filled*/,
538 rect.x, rect.y, rect.width, rect.height );
542 updateThreadsPanel( void )
555 for (t = all_threads; t != END_TSO_QUEUE; t = t->global_link) {
556 switch (t->what_next) {
557 case ThreadKilled: break;
558 case ThreadComplete: break;
560 switch (t->why_blocked) {
561 case BlockedOnRead: b_read++; break;
562 case BlockedOnWrite: b_write++; break;
563 case BlockedOnDelay: sleeping++; break;
564 case BlockedOnMVar: b_mvar++; break;
565 case BlockedOnException: b_throwto++; break;
566 case BlockedOnBlackHole: b_bh++; break;
567 case NotBlocked: running++; break;
571 total = running + b_read + b_write + b_mvar + b_throwto + b_bh + sleeping;
572 numLabel(running_label, running);
573 numLabel(b_read_label, b_read);
574 numLabel(b_write_label, b_write);
575 numLabel(b_mvar_label, b_mvar);
576 numLabel(b_bh_label, b_bh);
577 numLabel(b_throwto_label, b_throwto);
578 numLabel(sleeping_label, sleeping);
579 numLabel(total_label, total);
582 typedef enum { Thunk, Fun, Constr, BlackHole,
583 Array, Thread, Other, N_Cats } ClosureCategory;
587 static nat *res_prof[N_SLICES];
588 static double res_time[N_SLICES];
589 static nat next_slice = 0;
592 residencyCensus( void )
594 nat slice = next_slice++, *prof;
596 nat g, s, size, type;
600 if (slice >= N_SLICES) {
601 barf("too many slices");
603 res_prof[slice] = stgMallocBytes(N_Cats * sizeof(nat), "residencyCensus");
604 prof = res_prof[slice];
605 memset(prof, 0, N_Cats * sizeof(nat));
607 res_time[slice] = mut_user_time();
609 for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
610 for(s = 0; s < generations[g].n_steps; s++) {
612 /* skip over g0s0 if multi-generational */
613 if (RtsFlags.GcFlags.generations > 1 &&
614 g == 0 && s == 0) continue;
616 if (RtsFlags.GcFlags.generations == 1) {
617 bd = generations[g].steps[s].to_space;
619 bd = generations[g].steps[s].blocks;
622 for (; bd != NULL; bd = bd->link) {
626 while (p < bd->free) {
627 info = get_itbl((StgClosure *)p);
630 switch (info->type) {
632 size = bco_sizeW((StgBCO *)p);
637 if (((StgClosure *)p)->header.info == &DEAD_WEAK_info) {
638 size = sizeofW(StgWeak);
642 /* else, fall through... */
648 size = sizeW_fromITBL(info);
654 size = sizeofW(StgHeader) + 1;
660 size = sizeW_fromITBL(info);
668 size = sizeofW(StgHeader) + 2;
674 size = sizeW_fromITBL(info);
680 case SE_CAF_BLACKHOLE:
684 size = sizeW_fromITBL(info);
689 size = pap_sizeW((StgPAP *)p);
694 size = pap_sizeW((StgPAP *)p);
699 size = arr_words_sizeW(stgCast(StgArrWords*,p));
704 case MUT_ARR_PTRS_FROZEN:
705 size = mut_arr_ptrs_sizeW((StgMutArrPtrs *)p);
710 size = tso_sizeW((StgTSO *)p);
720 case IND_OLDGEN_PERM:
721 size = sizeW_fromITBL(info);
726 barf("updateResidencyGraph: strange closure "
740 updateResidencyGraph( void )
742 nat total, prev_total, i, max_res;
744 double time_scale = 1;
745 nat last_slice = next_slice-1;
746 double res_scale = 1; /* in megabytes, doubles */
751 gdk_draw_rectangle (res_pixmap,
752 res_drawing_area->style->bg_gc[GTK_STATE_NORMAL],
755 res_drawing_area->allocation.width,
756 res_drawing_area->allocation.height);
758 if (next_slice == 0) return;
760 time = res_time[last_slice];
761 while (time > time_scale) {
766 for (i = 0; i < next_slice; i++) {
768 total = prof[Thunk] + prof[Fun] + prof[Constr] +
769 prof[BlackHole] + prof[Array] + prof[Other];
770 if (total > max_res) {
774 while (max_res > res_scale) {
778 height = res_drawing_area->allocation.height;
779 width = res_drawing_area->allocation.width;
782 points[0].y = height;
783 points[1].y = height;
785 points[3].y = height;
787 gdk_gc_set_foreground(my_gc, &free_color);
790 for (i = 0; i < next_slice; i++) {
792 total = prof[Thunk] + prof[Fun] + prof[Constr] +
793 prof[BlackHole] + prof[Array] + prof[Other];
794 points[1].x = width * res_time[i] / time_scale;
795 points[2].x = points[1].x;
796 points[2].y = height - ((height * total) / res_scale);
797 gdk_draw_polygon(res_pixmap, my_gc, TRUE/*filled*/, points, 4);
798 points[3] = points[2];
799 points[0] = points[1];
802 gtk_ruler_set_range( GTK_RULER(res_vruler),
803 res_scale / ((1024*1024)/sizeof(W_)),
805 res_scale / ((1024*1024)/sizeof(W_)) );
807 gtk_ruler_set_range( GTK_RULER(res_hruler),
808 0, time_scale, 0, time_scale );
811 gtk_widget_draw( res_drawing_area, NULL );
814 #endif /* RTS_GTK_FRONTPANEL */