Allow IO to be wrapped in a newtype in foreign import/export
[ghc-hetmet.git] / rts / FrontPanel.c
1 /* -----------------------------------------------------------------------------
2  *
3  * (c) The GHC Team 2000
4  *
5  * RTS GTK Front Panel
6  *
7  * ---------------------------------------------------------------------------*/
8
9 #ifdef RTS_GTK_FRONTPANEL
10
11 /* Alas, not Posix. */
12 /* #include "PosixSource.h" */
13
14 #include "Rts.h"
15 #include "RtsUtils.h"
16 #include "MBlock.h"
17 #include "FrontPanel.h"
18 #include "Storage.h"
19 #include "Stats.h"
20 #include "RtsFlags.h"
21 #include "Schedule.h"
22
23 #include <gtk/gtk.h>
24 #include <unistd.h>
25 #include <string.h>
26
27 #include "VisSupport.h"
28 #include "VisWindow.h"
29
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;
40
41 static guint status_context_id;
42
43 gboolean continue_now = FALSE, stop_now = FALSE, quit = FALSE;
44 UpdateMode update_mode = Continuous;
45
46 static GdkPixmap *map_pixmap = NULL;
47 static GdkPixmap *gen_pixmap = NULL;
48 static GdkPixmap *res_pixmap = NULL;
49
50 #define N_GENS 10
51
52 static GdkColor 
53     bdescr_color = { 0, 0xffff, 0, 0 }, /* red */
54     free_color   = { 0, 0, 0, 0xffff }, /* blue */
55     gen_colors[N_GENS] = {
56         { 0, 0, 0xffff, 0 },
57         { 0, 0, 0xf000, 0 },
58         { 0, 0, 0xe000, 0 },
59         { 0, 0, 0xd000, 0 },
60         { 0, 0, 0xc000, 0 },
61         { 0, 0, 0xb000, 0 },
62         { 0, 0, 0xa000, 0 },
63         { 0, 0, 0x9000, 0 },
64         { 0, 0, 0x8000, 0 },
65         { 0, 0, 0x7000, 0 }
66     };
67
68 GdkGC *my_gc = NULL;
69
70 static void *mem_start = (void *) 0x50000000;
71
72 static void colorBlock( void *addr, GdkColor *color, 
73                         nat block_width, nat block_height, 
74                         nat blocks_per_line );
75
76 static void residencyCensus( void );
77 static void updateResidencyGraph( void );
78 static void updateThreadsPanel( void );
79
80 /* Some code pinched from examples/scribble-simple in the GTK+
81  * distribution.
82  */
83
84 /* Create a new backing pixmap of the appropriate size */
85 static gint 
86 configure_event( GtkWidget *widget, GdkEventConfigure *event STG_UNUSED,
87                  GdkPixmap **pixmap )
88 {
89   if (*pixmap)
90     gdk_pixmap_unref(*pixmap);
91
92   *pixmap = gdk_pixmap_new(widget->window,
93                            widget->allocation.width,
94                            widget->allocation.height,
95                            -1);
96
97   gdk_draw_rectangle (*pixmap,
98                       widget->style->white_gc,
99                       TRUE,
100                       0, 0,
101                       widget->allocation.width,
102                       widget->allocation.height);
103
104   debugBelch("configure!\n");
105   updateFrontPanel();
106   return TRUE;
107 }
108
109 /* Redraw the screen from the backing pixmap */
110 static gint 
111 expose_event( GtkWidget *widget, GdkEventExpose *event, GdkPixmap **pixmap )
112 {
113   gdk_draw_pixmap(widget->window,
114                   widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
115                   *pixmap,
116                   event->area.x, event->area.y,
117                   event->area.x, event->area.y,
118                   event->area.width, event->area.height);
119
120   return FALSE;
121 }
122
123 void
124 initFrontPanel( void )
125 {
126     GdkColormap *colormap;
127     GtkWidget *gen_hbox;
128
129     gtk_init( &prog_argc, &prog_argv );
130
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");
156     
157     status_context_id = 
158         gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "context" );
159
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);
165
166     gtk_widget_set_events(map_drawing_area, GDK_EXPOSURE_MASK);
167
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);
173
174     gtk_widget_set_events(gen_drawing_area, GDK_EXPOSURE_MASK);
175     
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);
181
182     gtk_widget_set_events(res_drawing_area, GDK_EXPOSURE_MASK);
183     
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);
188
189     {
190         gboolean success[N_GENS];
191         gdk_colormap_alloc_colors(colormap, gen_colors, N_GENS, TRUE,
192                                   TRUE, success);
193         if (!success) { barf("can't allocate colors"); }
194     }
195
196     /* set the labels on the generation histogram */
197     {
198         char buf[64];
199         nat g, s;
200         GtkWidget *label;
201
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,
207                                     TRUE, TRUE, 5 );
208                 gtk_widget_show(label);
209             }
210         }
211     }
212
213     gtk_widget_show(window);
214
215     /* wait for the user to press "Continue" before getting going... */
216     gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, 
217                         "Program start");
218     gtk_widget_set_sensitive( stop_but, FALSE );
219     continue_now = FALSE;
220     while (continue_now == FALSE) {
221         gtk_main_iteration();
222     }
223     gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
224     gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, 
225                         "Running");
226
227     gtk_widget_set_sensitive( continue_but, FALSE );
228     gtk_widget_set_sensitive( stop_but, TRUE );
229     gtk_widget_set_sensitive( quit_but, FALSE );
230
231     while (gtk_events_pending()) {
232         gtk_main_iteration();
233     }
234 }
235
236 void
237 stopFrontPanel( void )
238 {
239     gtk_widget_set_sensitive( quit_but, TRUE );
240     gtk_widget_set_sensitive( continue_but, FALSE );
241     gtk_widget_set_sensitive( stop_but, FALSE );
242
243     updateFrontPanel();
244
245     gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, 
246                         "Program finished");
247
248     quit = FALSE;
249     while (quit == FALSE) {
250         gtk_main_iteration();
251     }
252 }
253
254 static void
255 waitForContinue( void )
256 {
257     gtk_widget_set_sensitive( continue_but, TRUE );
258     gtk_widget_set_sensitive( stop_but, FALSE );
259     stop_now = FALSE;
260     continue_now = FALSE;
261     while (continue_now == FALSE) {
262         gtk_main_iteration();
263     }
264     gtk_widget_set_sensitive( continue_but, FALSE );
265     gtk_widget_set_sensitive( stop_but, TRUE );
266 }
267
268 void
269 updateFrontPanelBeforeGC( nat N )
270 {
271     char buf[1000];
272
273     updateFrontPanel();
274
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 );
280         waitForContinue();
281         gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
282     }
283
284     g_snprintf( buf, 1000, "Garbage collecting (generation %d)", N );
285     gtk_statusbar_push( GTK_STATUSBAR(statusbar), status_context_id, buf);
286
287     while (gtk_events_pending()) {
288         gtk_main_iteration();
289     }
290 }
291
292 static void
293 numLabel( GtkWidget *lbl, nat n )
294 {
295     char buf[64];
296     g_snprintf(buf, 64, "%d", n);
297     gtk_label_set_text( GTK_LABEL(lbl), buf );
298 }
299
300 void
301 updateFrontPanelAfterGC( nat N, lnat live )
302 {
303     char buf[1000];
304
305     gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
306
307     /* is a major GC? */
308     if (N == RtsFlags.GcFlags.generations-1) {
309         residencyCensus();
310     }
311
312     updateFrontPanel();
313
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 );
319         waitForContinue();
320         gtk_statusbar_pop( GTK_STATUSBAR(statusbar), status_context_id );
321     }
322
323     {
324         double words_to_megs = (1024 * 1024) / sizeof(W_);
325         double time = mut_user_time();
326
327         snprintf( buf, 1000, "%.2f", (double)live / words_to_megs );
328         gtk_label_set_text( GTK_LABEL(live_label), buf );
329
330         snprintf( buf, 1000, "%.2f", (double)total_allocated / words_to_megs );
331         gtk_label_set_text( GTK_LABEL(allocated_label), buf );
332
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 );
336
337         if ( time == 0.0 )
338             snprintf( buf, 1000, "%.2f", time );
339         else
340             snprintf( buf, 1000, "%.2f",
341                       (double)(total_allocated / words_to_megs) / time );
342         gtk_label_set_text( GTK_LABEL(alloc_rate_label), buf );
343     }
344
345     while (gtk_events_pending()) {
346         gtk_main_iteration();
347     }
348 }
349
350 void
351 updateFrontPanel( void )
352 {
353     void *m, *a;
354     bdescr *bd;
355
356     updateThreadsPanel();
357
358     if (my_gc == NULL) {
359         my_gc = gdk_gc_new( window->window );
360     }
361
362     if (map_pixmap != NULL) {
363         nat height, width, blocks_per_line, 
364             block_height, block_width, mblock_height;
365
366         height = map_drawing_area->allocation.height;
367         width  = map_drawing_area->allocation.width;
368
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);
377         }
378         block_width = width / blocks_per_line;
379
380         gdk_draw_rectangle (map_pixmap,
381                             map_drawing_area->style->bg_gc[GTK_STATE_NORMAL],
382                             TRUE,
383                             0, 0,
384                             map_drawing_area->allocation.width,
385                             map_drawing_area->allocation.height);
386         
387         for ( m = mem_start; 
388               (char *)m < (char *)mem_start + 
389                   (mblocks_allocated * MBLOCK_SIZE); 
390               (char *)m += MBLOCK_SIZE ) {
391             
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 );
396             }
397             
398 #if 0 /* Segfaults because bd appears to be bogus but != NULL. stolz, 2003-06-24 */
399             /* color each block */
400             for (; a <= LAST_BLOCK(m); (char *)a += BLOCK_SIZE) {
401                 bd = Bdescr((P_)a);
402                 ASSERT(bd->start == a);
403                 if (bd->flags & BF_FREE) {
404                     colorBlock( a, &free_color, 
405                                 block_width, block_height, blocks_per_line );
406                 } else {
407                     colorBlock( a, &gen_colors[bd->gen_no],
408                                 block_width, block_height, blocks_per_line );
409                 }
410             }
411 #endif
412         }
413
414         
415         { 
416             nat height = map_drawing_area->allocation.height,
417                 block_height, mblock_height;
418
419             block_height = (height / mblocks_allocated) / 
420                 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
421             if (block_height < 1) block_height = 1;
422             mblock_height = block_height * 
423                 ((MBLOCK_SIZE/BLOCK_SIZE) / blocks_per_line);
424
425             gtk_ruler_set_range( GTK_RULER(map_ruler), 0, 
426                                  (double)(height * mblocks_allocated) / 
427                                  (double)((mblock_height * mblocks_allocated)),
428                                  0,
429                                  (double)(height * mblocks_allocated) / 
430                                  (double)((mblock_height * mblocks_allocated))
431                 );
432         }
433                                   
434         gtk_widget_draw( map_drawing_area, NULL );
435     }
436
437     if (gen_pixmap != NULL) {
438
439         GdkRectangle rect;
440         nat g, s, columns, column, max_blocks, height_blocks,
441             width, height;
442         
443         gdk_draw_rectangle (gen_pixmap,
444                             gen_drawing_area->style->white_gc,
445                             TRUE,
446                             0, 0,
447                             gen_drawing_area->allocation.width,
448                             gen_drawing_area->allocation.height);
449
450         height = gen_drawing_area->allocation.height;
451         width  = gen_drawing_area->allocation.width;
452
453         columns = 0; max_blocks = 0;
454         for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
455             columns += generations[g].n_steps;
456             for(s = 0; s < generations[g].n_steps; s++) {
457                 if (generations[g].steps[s].n_blocks > max_blocks) {
458                     max_blocks = generations[g].steps[s].n_blocks;
459                 }
460             }
461         }
462
463         /* find a reasonable height value larger than max_blocks */
464         { 
465             nat n = 0;
466             while (max_blocks != 0) {
467                 max_blocks >>= 1; n++;
468             }
469             height_blocks = 1 << n;
470         }
471
472         column = 0;
473         for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
474             for(s = 0; s < generations[g].n_steps; s++, column++) {
475                 gdk_gc_set_foreground(my_gc, &gen_colors[g]);
476
477                 rect.x = column * (width / columns);
478
479                 if (generations[g].steps[s].n_blocks == 0)
480                     rect.y = height;
481                 else
482                     rect.y = height - 
483                         (height * generations[g].steps[s].n_blocks
484                          / height_blocks);
485
486                 rect.width = (width / columns);
487                 rect.height = height - rect.y;
488
489                 gdk_draw_rectangle( gen_pixmap, my_gc, TRUE/*filled*/, 
490                                     rect.x, rect.y, rect.width,
491                                     rect.height );
492             }
493         }
494
495         gtk_ruler_set_range( GTK_RULER(gen_ruler), 
496                              height_blocks * BLOCK_SIZE / (1024 * 1024),
497                              0, 0,
498                              height_blocks * BLOCK_SIZE / (1024 * 1024)
499             );
500
501         gtk_widget_draw( gen_drawing_area, NULL );
502     }
503
504     if (res_pixmap != NULL) {
505         updateResidencyGraph();
506     }
507
508     while (gtk_events_pending()) {
509         gtk_main_iteration_do(FALSE/*don't block*/);
510     }
511 }
512
513 static void
514 colorBlock( void *addr, GdkColor *color, 
515             nat block_width, nat block_height, nat blocks_per_line )
516 {
517     GdkRectangle rect;
518     nat block_no;
519
520     gdk_gc_set_foreground(my_gc, color);
521
522     block_no = ((char *)addr - (char *)mem_start) / BLOCK_SIZE;
523
524     rect.x = (block_no % blocks_per_line) * block_width;
525     rect.y = block_no / blocks_per_line * block_height;
526     rect.width = block_width;
527     rect.height = block_height;
528     gdk_draw_rectangle( map_pixmap, my_gc, TRUE/*filled*/, 
529                         rect.x, rect.y, rect.width, rect.height );
530 }
531
532 static void
533 updateThreadsPanel( void )
534 {
535     nat running = 0,
536         b_read = 0,
537         b_write = 0,
538         b_mvar = 0,
539         b_throwto = 0,
540         b_bh = 0,
541         sleeping = 0,
542         total = 0;
543
544     StgTSO *t;
545
546     for (t = all_threads; t != END_TSO_QUEUE; t = t->global_link) {
547         switch (t->what_next) {
548         case ThreadKilled:          break;
549         case ThreadComplete:        break;
550         default:
551             switch (t->why_blocked) {
552             case BlockedOnRead:       b_read++;    break;
553             case BlockedOnWrite:      b_write++;   break;
554             case BlockedOnDelay:      sleeping++;  break;
555             case BlockedOnMVar:       b_mvar++;    break;
556             case BlockedOnException:  b_throwto++; break;
557             case BlockedOnBlackHole:  b_bh++;      break;
558             case NotBlocked:          running++;   break;
559             }
560         }
561     }
562     total = running + b_read + b_write + b_mvar + b_throwto + b_bh + sleeping;
563     numLabel(running_label,   running);
564     numLabel(b_read_label,    b_read);
565     numLabel(b_write_label,   b_write);
566     numLabel(b_mvar_label,    b_mvar);
567     numLabel(b_bh_label,      b_bh);
568     numLabel(b_throwto_label, b_throwto);
569     numLabel(sleeping_label,  sleeping);
570     numLabel(total_label,     total);
571 }
572
573 typedef enum { Thunk, Fun, Constr, BlackHole,
574                Array, Thread, Other, N_Cats } ClosureCategory;
575
576 #define N_SLICES 100
577
578 static nat *res_prof[N_SLICES];
579 static double res_time[N_SLICES];
580 static nat next_slice = 0;
581
582 static void
583 residencyCensus( void )
584 {
585     nat slice = next_slice++, *prof;
586     bdescr *bd;
587     nat g, s, size, type;
588     StgPtr p;
589     StgInfoTable *info;
590
591     if (slice >= N_SLICES) {
592         barf("too many slices");
593     }
594     res_prof[slice] = stgMallocBytes(N_Cats * sizeof(nat), "residencyCensus");
595     prof = res_prof[slice];
596     memset(prof, 0, N_Cats * sizeof(nat));
597
598     res_time[slice] = mut_user_time();
599     
600     for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
601         for(s = 0; s < generations[g].n_steps; s++) {
602
603             /* skip over g0s0 if multi-generational */
604             if (RtsFlags.GcFlags.generations > 1 &&
605                 g == 0 && s == 0) continue;
606
607             if (RtsFlags.GcFlags.generations == 1) {
608 /*              bd = generations[g].steps[s].to_blocks; FIXME to_blocks does not exist */
609             } else {
610                 bd = generations[g].steps[s].blocks;
611             }
612
613             for (; bd != NULL; bd = bd->link) {
614
615                 p = bd->start;
616
617                 while (p < bd->free) {
618                     info = get_itbl((StgClosure *)p);
619                     type = Other;
620                     
621                     switch (info->type) {
622
623                     case CONSTR:
624                     case BCO:
625                         if (((StgClosure *)p)->header.info == &stg_DEAD_WEAK_info) {
626                             size = sizeofW(StgWeak);
627                             type = Other;
628                             break;
629                         }
630                         /* else, fall through... */
631                     case CONSTR_1_0:
632                     case CONSTR_0_1:
633                     case CONSTR_1_1:
634                     case CONSTR_0_2:
635                     case CONSTR_2_0:
636                         size = sizeW_fromITBL(info);
637                         type = Constr;
638                         break;
639                         
640                     case FUN_1_0:
641                     case FUN_0_1:
642                         size = sizeofW(StgHeader) + 1;
643                         goto fun;
644                     case FUN_1_1:
645                     case FUN_0_2:
646                     case FUN_2_0:
647                     case FUN:
648                         size = sizeW_fromITBL(info);
649                     fun:
650                         type = Fun;
651                         break;
652
653                     case THUNK_1_0:
654                     case THUNK_0_1:
655                     case THUNK_SELECTOR:
656                         size = sizeofW(StgHeader) + 2;
657                         goto thunk;
658                     case THUNK_1_1:
659                     case THUNK_0_2:
660                     case THUNK_2_0:
661                     case THUNK:
662                         size = sizeW_fromITBL(info);
663                     thunk:
664                         type = Thunk;
665                         break;
666
667                     case CAF_BLACKHOLE:
668                     case SE_CAF_BLACKHOLE:
669                     case SE_BLACKHOLE:
670                     case BLACKHOLE:
671 /*                  case BLACKHOLE_BQ: FIXME: case does not exist */
672                         size = sizeW_fromITBL(info);
673                         type = BlackHole;
674                         break;
675
676                     case AP:
677                         size = pap_sizeW((StgPAP *)p);
678                         type = Thunk;
679                         break;
680
681                     case PAP:
682                         size = pap_sizeW((StgPAP *)p);
683                         type = Fun;
684                         break;
685                         
686                     case ARR_WORDS:
687                         size = arr_words_sizeW(stgCast(StgArrWords*,p));
688                         type = Array;
689                         break;
690                         
691                     case MUT_ARR_PTRS:
692                     case MUT_ARR_PTRS_FROZEN:
693                         size = mut_arr_ptrs_sizeW((StgMutArrPtrs *)p);
694                         type = Array;
695                         break;
696                         
697                     case TSO:
698                         size = tso_sizeW((StgTSO *)p);
699                         type = Thread;
700                         break;
701                         
702                     case WEAK:
703                     case STABLE_NAME:
704                     case MVAR:
705                     case MUT_VAR:
706 /*                  case MUT_CONS: FIXME: case does not exist */
707                     case IND_PERM:
708                     case IND_OLDGEN_PERM:
709                         size = sizeW_fromITBL(info);
710                         type = Other;
711                         break;
712
713                     default:
714                         barf("updateResidencyGraph: strange closure "
715                              "%d", info->type );
716                     }
717
718                     prof[type] += size;
719                     p += size;
720                 }
721             }
722         }
723     }
724
725 }
726             
727 static void
728 updateResidencyGraph( void )
729 {
730     nat total, prev_total, i, max_res;
731     double time;
732     double time_scale = 1;
733     nat last_slice = next_slice-1;
734     double res_scale  = 1; /* in megabytes, doubles */
735     nat *prof;
736     nat width, height;
737     GdkPoint points[4];
738
739     gdk_draw_rectangle (res_pixmap,
740                         res_drawing_area->style->bg_gc[GTK_STATE_NORMAL],
741                         TRUE,
742                         0, 0,
743                         res_drawing_area->allocation.width,
744                         res_drawing_area->allocation.height);
745     
746     if (next_slice == 0) return;
747
748     time = res_time[last_slice];
749     while (time > time_scale) {
750         time_scale *= 2;
751     }
752
753     max_res = 0; 
754     for (i = 0; i < next_slice; i++) {
755         prof = res_prof[i];
756         total = prof[Thunk] + prof[Fun] + prof[Constr] +
757             prof[BlackHole] + prof[Array] + prof[Other];
758         if (total > max_res) {
759             max_res = total;
760         }
761     }
762     while (max_res > res_scale) {
763         res_scale *= 2;
764     }
765
766     height = res_drawing_area->allocation.height;
767     width  = res_drawing_area->allocation.width;
768
769     points[0].x = 0;
770     points[0].y = height;
771     points[1].y = height;
772     points[3].x = 0;
773     points[3].y = height;
774
775     gdk_gc_set_foreground(my_gc, &free_color);
776
777     prev_total = 0;
778     for (i = 0; i < next_slice; i++) {
779         prof = res_prof[i];
780         total = prof[Thunk] + prof[Fun] + prof[Constr] +
781             prof[BlackHole] + prof[Array] + prof[Other];
782         points[1].x = width * res_time[i] / time_scale;
783         points[2].x = points[1].x;
784         points[2].y = height - ((height * total) / res_scale);
785         gdk_draw_polygon(res_pixmap, my_gc, TRUE/*filled*/, points, 4);
786         points[3] = points[2];
787         points[0] = points[1];
788     }
789
790     gtk_ruler_set_range( GTK_RULER(res_vruler), 
791                          res_scale / ((1024*1024)/sizeof(W_)),
792                          0, 0,
793                          res_scale / ((1024*1024)/sizeof(W_)) );
794
795     gtk_ruler_set_range( GTK_RULER(res_hruler), 
796                          0, time_scale, 0, time_scale );
797
798
799     gtk_widget_draw( res_drawing_area, NULL );
800 }
801
802 #endif /* RTS_GTK_FRONTPANEL */