/* Sun-$Revision: 23.2 $ */ /* Copyright 1992-9 Sun Microsystems, Inc. and Stanford University. See the LICENSE file for license information. */ # pragma interface // Pieces of the spy. // These classes are needed by the spy, but not references by the rest of the VM. // First, non-graphical pieces. These are called by the spy // to figure out what has been going on. // They in turn call out to the VM: class ProcessTime { friend class ProcessInfo; private: int _secs; int _nano_secs; public: void clear() { _secs = _nano_secs = 0; } int secs() { return _secs; } int nano_secs() { return _nano_secs; } int micro_secs() { return _nano_secs / 1000; } int milli_secs() { return secs() * 1000 + micro_secs() / 1000; } float milli_secs_as_float() { return ((float) secs()) * 1000.0 + ((float) nano_secs()) / 1000000.0; } ProcessTime operator-(const ProcessTime& t); ProcessTime operator+(const ProcessTime& t); static ProcessTime get_real_time(); }; // Interface to the resource utilization for the running process. class ProcessInfo /* AllStatic */ { public: // Takes a snapshot of the current resource utilization. static void update(); // Returns the number of page faults requiring physical I/O. static int page_faults_IO(); // Returns the number of page faults NOT requiring physical I/O. static int page_faults_NonIO(); // Returns the number of block input operations. static int block_input_operations(); // Returns the number of block output operations. static int block_output_operations(); // Returns the number of forces context switches. static int forced_context_switches(); // Returns the number of volunatry context switches. static int voluntary_context_switches(); // Returns the user time. static ProcessTime user_time(); // Returns the system time. static ProcessTime system_time(); }; class OSActivityMonitor { public: enum SystemState { nothing, reading, writing, disk_IO, disk_in, disk_out, in_os, idle}; static OSActivityMonitor::SystemState activity(); static char* state_string(OSActivityMonitor::SystemState); }; class LoadLevelMonitor { public: static void initialize(); static void compute_load_level(); static fint load_level; // [0..100]; 50 = we're missing half the ticks }; class ResourceAreaMonitor { public: static bool is_consistent(); static int32 used(); }; class InterruptedFrameMonitor { public: static void get_frame_and_pc( frame*& f, char*& pc ); }; // Now. the graphical pieces: // ******************* action indicators ********************* // Shows some text 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); // C++ compiler gives warnings, forcing me to change the names virtual void show(char *text); void hide(); }; // Constant text 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 SlidingAverage; 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); 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; } protected: static void printWithCommas(char* s, fint length, fint offset, int32 n); }; 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); }; class CompileIndicator : public Indicator { friend class SelfMonitor; // uses compile_len private: static const int compile_len = 100; char name[compile_len]; public: CompileIndicator() : Indicator() {}; void show(char *name, char* compiler, bool recompiling); }; // A MonitorBar represents a bar displaying a space's allocation status. // Spaces have a lower and an upper part (growing in opposite directions); // the latter can be of size 0 (e.g. the zone) class MonitorBar: public CHeapObj { public: fint x, y, w, h; protected: fint old_len_1, old_len_2; fint in_core_percentage_1; // % of space in real memory [0..100] fint in_core_percentage_2; public: MonitorBar(); void resize(fint X, fint Y, fint W, fint H); virtual void init(); void draw(bool incremental); virtual void draw_long_term(bool mustDraw) { Unused(mustDraw); } virtual void calculate_VM_stats(); // update in_core_percentage virtual int32 capacity() = 0; virtual int32 used1() = 0; virtual int32 used2() { return 0; } protected: virtual char* start1() = 0; virtual char* start2() { return NULL; } void calculateVMRegion( int32 startAddr, int32 size, fint& in_core_percentage, fint& oldlen); }; class MonitorMemBar : public MonitorBar { private: space *s; public: MonitorMemBar(space *S) : MonitorBar() { s = S; init(); } int32 capacity() { return s->capacity(); } int32 used1() { return s->oops_used() * sizeof(oop); } int32 used2() { return s->bytes_used(); } char* start1() { return (char*) s->oopsStart(); } char* start2() { return s->bytesStart(); } void resize(fint X, fint Y, fint H, fint factor); }; # if defined(FAST_COMPILER) || defined(SIC_COMPILER) class MonitorZoneBar : public MonitorBar { private: Heap* z; public: MonitorZoneBar(Heap* Z) : MonitorBar() { z = Z; } int32 capacity() { return z->capacity(); } int32 used1() { return z->usedBytes(); } char* start1() { return z->startAddr(); } void resize(fint X, fint Y, fint H, fint factor, Heap *newZ= NULL); }; class MonitorCodeCacheBar : public MonitorZoneBar { public: MonitorCodeCacheBar(Heap *Z) : MonitorZoneBar(Z) { } int32 used1() { return Memory->code->used_per_compiler[nm_nic]; } int32 used2() { return Memory->code->used_per_compiler[nm_sic]; } void calculate_VM_stats(); }; # endif // defined(FAST_COMPILER) || defined(SIC_COMPILER) class MonitorCPUBar : public MonitorBar { // keep the CPU usage as a sliding average over n_intervals intervals static const int n_intervals = 10; int32 interval_usec; // microseconds in one time interval int32 interval_usecN; // microseconds in n_intervals time intervals int32 usedU, used_usecsU[n_intervals], usecsU, secsU, sum_usecsU; int32 usedS, used_usecsS[n_intervals], usecsS, secsS, sum_usecsS; fint n; public: MonitorCPUBar(int32 usec); void init(); void init_CPU(); int32 capacity() { return 100; } inline int32 used1(); int32 current_usage() { return (usedU + usedS); } char* start1() { return NULL; } void calculate_VM_stats(); void update(); }; class MonitorSampledBar : public MonitorBar { // keep system usage as a sliding average over n_samples intervals // has 4 categories static const int n_samples = 10; fint sum1, samples1[n_samples]; fint sum2, samples2[n_samples]; fint sum3, samples3[n_samples]; fint sum4, samples4[n_samples]; double sum1T, sum2T, sum3T, sum4T, elapsedT; // totals - floats to avoid overflow fint old_lta1, old_lta2, old_lta3, old_lta4; // long-term averages [0..w) fint elapsed_ticks, ticks[n_samples]; fint n; public: MonitorSampledBar(); void init(); int32 capacity() { return elapsed_ticks ? elapsed_ticks : 100; } int32 used1(); int32 used2(); char* start1() { return NULL; } void calculate_VM_stats(); void update(fint count1, fint count2, fint elapsed_ticks); void update(fint count1, fint count2, fint count3, fint count4, fint elapsed_ticks); void update0(); void draw_long_term(bool mustDraw); };