/* Sun-$Revision: 23.10 $ */
/* Copyright 1992-9 Sun Microsystems, Inc. and Stanford University.
See the LICENSE file for license information. */
# pragma interface
// monitor monitors system activity ("Self spy")
// the platform-specific one should be typedefed to monitor
class memBarDesc;
class cpuBarDesc;
class sampledBarDesc;
class zoneBarDesc;
class Indicator;
class SharedIndicator;
enum SYS_state { nothing,
reading, writing, disk_IO, disk_in, disk_out, in_unix, idle};
class abstract_monitor: public CHeapObj {
friend class barDesc;
friend class sampledBarDesc;
protected:
virtual bool openWindow();
virtual bool handleEvents();
public:
fint loadLevel; // [0..100]; 50 = we're missing half the ticks
int32 totalTickNo; // # of ticks since start
int32 usedTicks; // # of ticks of CPU used since start
fint elapsedTicks; // ticks since last screen update
fint ticks_per_second;
protected:
// for unix, _allocated starts at 0, and is updated by malloc/free
// for mac, _allocated starts at FreeMem(), and allocated() is _allocated - FreeMem()
int32 _allocated; // bytes allocated with malloc()
Indicator* page;
bool paging;
SYS_state systemState;
SharedIndicator* sys;
protected:
void showPaging(long how_many);
void hidePaging();
public:
bool showSends; // show optional info on sends / blocks?
bool incremental; // set to true if nobody else will draw in
// our portion of the screen
bool active; // true if spy is running
int32 tickNo; // # of tick within this second
FILE* logf; // log file
char* logfn; // log file name
abstract_monitor();
~abstract_monitor();
virtual void set_oldT() {}
void closeWindow();
void tick_measure();
virtual void tick_redraw() = 0;
virtual void get_interrupted_frame_and_pc( frame*& f, char*& pc ) {
f = NULL; pc = NULL; }
virtual bool get_graphics_semaphore() { return false; }
void show_activities();
virtual void show_os_stuff();
void show_sends();
void update_time_bars();
void update_load_level();
virtual fint compute_load_level() { return 0; }
virtual int32 allocated() = 0;
void reset(); // for AbortProcess etc.
fint max_height() {return 0;}; // height of monitor in pixels
// to adjust "size" of C-Heap; 0 means reset to zero, < 0 make smaller etc
void resetCHeapValue(int32 delta = 0);
virtual void reset_allocated();
// components
memBarDesc* eden;
memBarDesc* from;
memBarDesc* to;
int nOld;
memBarDesc **old;
# if defined(FAST_COMPILER) || defined(SIC_COMPILER)
zoneBarDesc* iZone;
zoneBarDesc* dZone;
zoneBarDesc* sZone;
zoneBarDesc* picZone;
# endif
cpuBarDesc* cpuBar;
sampledBarDesc* selfBar;
sampledBarDesc* lookupBar;
sampledBarDesc* compilerBar;
sampledBarDesc* vmBar;
sampledBarDesc* accessBar;
int bpp;
int pixelsPerMb;
int mem_usage_line_len;
int ruler_len;
bool spyIsMono;
void mem_reserve_changed() { mem_usage_line_len= 0; }
// the following are defined in class "monitor" so they
// can use macros & inlines instead of virtuals
public:
void activate(char* filename = NULL) {
Unused(filename); SubclassResponsibility(); }
void adjust_after_resize();
protected:
virtual void resizeMZBars() = 0;
virtual void set_bytes_per_pixel() = 0;
// to optimize, make this virt and callees nonvirt
void pre_redraw() {}
void post_redraw() {}
public:
virtual void addOldBar(oldSpace *s) = 0;
protected:
virtual void draw_mem_usage_line(bool b) = 0;
virtual void draw_reserve_lines() = 0;
virtual void draw_memory_ruler() = 0;
virtual void enroll() = 0;
virtual void withdraw() = 0;
protected:
virtual int get_ticks_per_second();
friend class Indicator;
friend class oldGeneration;
friend void selfs_free(void* ptr);
// former inlines, dummy versions here
protected:
int screen_width() { return 1; }
int window_width() { return 1; }
int screen_height() { return 1; }
int window_height() { return 1; }
int font_w() { return 1; }
int font_h() { return 1; }
void set_port() {}
void reset_port() {}
void draw_text(char* /*text*/, int /*x*/, int /*y*/) {}
void clear_rectangle(int /*x*/, int /*y*/, int /*w*/, int /*h*/) {}
void draw_square(int /*x*/, int /*y*/, int /*s*/) {}
void clear_square(int /*x*/, int /*y*/, int /*s*/) {}
void draw_line(int /*x1*/, int /*y1*/, int /*x2*/, int /*y2*/) {}
void set_color(int /*c*/) {}
void set_thickness(int /*t*/) {}
void fill_rectangle_black(int /*x*/, int /*y*/, int /*w*/, int /*h*/) {}
void fill_rectangle_white(int /*x*/, int /*y*/, int /*w*/, int /*h*/) {}
void draw_rectangle_black(int /*x*/, int /*y*/, int /*w*/, int /*h*/) {}
void set_grey() {}
void set_solid() {}
void set_xor() {}
void set_copy() {}
// spy log file operations
public:
static oop resetLog_prim(oop rcvr);
static oop annotateLog_prim(oop rcvr);
protected:
static FILE* openLogFile(char* filename);
static void set_log_buf(FILE* /*f*/, char* /*buf*/, int /*bs*/) {}
};
extern fint lookupNesting; // > 0 means lookup in progress
struct showLookup {
showLookup() { lookupNesting++; }
~showLookup() { lookupNesting--; }
};
extern char* methodBeingCompiled;
class showCompile: CHeapObj {
void doShowCompile(oop selector, char* compiler, bool opt);
public:
showCompile(oop selector, char* compiler, bool optimize);
~showCompile();
};
class showVMActivity: CHeapObj {
char* oldActivity;
public:
showVMActivity(char* what);
~showVMActivity();
};
// keeps a sliding average over the last N values
class SlidingAverage : public CHeapObj {
int32* values;
fint n; // window size
fint index; // next value to use
int32 _sum; // sliding sum
public:
SlidingAverage(fint N) {
assert(N > 0, "must be positive");
n = N; values = (int32*)AllocateHeap(N * sizeof(int32), "spy avg"); reset();
}
~SlidingAverage() { delete values; }
void reset() {
index = 0; _sum = 0;
for (fint i = 0; i < n; i++) values[i] = 0;
}
void add(int32 v) {
_sum -= values[index]; values[index] = v; _sum += v;
index = index == n - 1 ? 0 : index + 1;
}
int32 average() { return _sum / n; }
int32 sum() { return _sum; }
};
void monitor_tick_measure();
void monitor_tick_redraw();
// ******************* action indicators *********************
class Indicator: public CHeapObj {
protected:
fint x, y, w;
bool visible;
void draw_under();
public:
Indicator();
virtual void reposition(fint X, fint Y, fint W);
virtual void show(char *text);
virtual void show() { SilenceOverrideWarning(); }
virtual void show(char *text, fint new_state) {
Unused(text); Unused( new_state ); SilenceOverrideWarning(); }
virtual void show(char *name, char* compiler, bool recompiling) {
Unused(name); Unused(compiler); Unused(recompiling);
SilenceOverrideWarning(); }
void hide();
};
class IndicatorLabel : public Indicator {
private:
char* text;
public:
IndicatorLabel(char* t) { text = t; }
void show() { Indicator::show(text); }
};
class SharedIndicator : public Indicator {
private:
fint state;
public:
SharedIndicator();
void show(char *text, fint new_state);
void hide();
};
class CompileIndicator : public Indicator {
# define COMPILE_LEN 100
private:
char name[COMPILE_LEN];
public:
CompileIndicator() : Indicator() {};
void show(char *name, char* compiler, bool recompiling);
};
class ValueIndicator : public Indicator {
protected:
char* text; // text string (with room at end for number)
int32 lastVal; // last value shown
SlidingAverage* data;
fint digits; // number of digits
fint offset; // offset of last digit (from right end of string)
bool showSum; // show sliding sum instead of average
public:
bool changed; // redrawn during last update() ?
ValueIndicator(char* t, bool sum, fint d, fint n = 1, fint off = 0) {
text = OS::strdup(t); showSum = sum; lastVal = -1; digits = d; offset = off;
data = new SlidingAverage(n);
}
void reposition(fint X, fint Y, fint W) {
Indicator::reposition(X, Y, W); show(); }
void show() { Indicator::show(text); }
virtual void update(int32 newVal, bool incremental);
int32 value() { return lastVal; }
};
class DifferenceIndicator : public ValueIndicator {
protected:
int32 lastSum; // last sum shown
public:
DifferenceIndicator(char* t, fint d, fint n = 1, fint off = 0)
: ValueIndicator(t, d, n, off) { lastSum = -1; }
void update(int32 newSum, bool incremental);
};
