spg_fs_info_.pl1 08/08/88 1130.2r w 08/08/88 1115.1 28998 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* SPG_FS_INFO_ - Get Bulk Store and Disk I/O Activity Meters. coded 9/24/76 by Noel I. Morris */ /* Modified May 1984 by T. Oke for adaptive disk optimization mods. */ /* Modified Oct 1984 by T. Oke to fix bugs of adaptive mods. */ /* Modified Dec 1984 by T. Oke to restrict peek size to limit of buffer. */ spg_fs_info_: procedure (pdio, dkio, vtio) options (separate_static); dcl pdio fixed bin, /* paging device I/O count */ dkio fixed bin, /* disk page I/O count */ vtio fixed bin; /* VTOC I/O count */ dcl code fixed bin (35), /* error code */ (cur_dkio, cur_vtio) fixed bin, /* current values */ dev fixed bin, /* device in disktab */ type fixed bin, /* IO type in devtab */ sx fixed bin, /* disk subsystem index */ r0dp ptr; /* pointer to ring zero disk database */ dcl buffer (3000) fixed bin; /* data buffer */ dcl dsp (31) ptr static init ((31) null ()), /* pointers to disk database */ subsys_size (32) fixed bin (18) static, /* size of each sub-system */ subsystems fixed bin static init (0), /* number of disk subsystems */ (prev_dkio, prev_vtio) fixed bin static init (0); /* previous values */ dcl ring0_get_$segptr entry (char (*), char (*), ptr, fixed bin (35)), ring_zero_peek_ entry (ptr, ptr, fixed bin (18), fixed bin (35)); dcl (addr, hbound, lbound, null, ptr, size) builtin; if subsystems = 0 then do; /* Get pointer to disk_seg. */ call ring0_get_$segptr ("", "disk_seg", r0dp, code); if code = 0 then do; disksp = addr (buffer); call ring_zero_peek_ (r0dp, disksp, size (disk_data), code); if code = 0 then do; subsystems = disk_data.subsystems; do sx = 1 to subsystems; dsp (sx) = ptr (r0dp, disk_data.offset (sx)); if sx ^= disk_data.subsystems then subsys_size (sx) = bin (disk_data.offset (sx + 1)) - bin (disk_data.offset (sx)); else subsys_size (sx) = bin (disk_data.free_offset) - bin (disk_data.offset (sx)); end; end; end; end; pdio, dkio, vtio = 0; cur_dkio, cur_vtio = 0; diskp = addr (buffer); do sx = 1 to subsystems; /* Iterate through disk subsystems. */ call ring_zero_peek_ (dsp (sx), diskp, min (hbound (buffer, 1), subsys_size (sx)), code); if code ^= 0 then return; do dev = lbound (disktab.devtab, 1) to hbound (disktab.devtab, 1); dp = addr (disktab.devtab (dev)); cur_dkio = cur_dkio + devtab.opt_info (PAGE_READ).seek_count + devtab.opt_info (PAGE_WRITE).seek_count; cur_vtio = cur_vtio + devtab.opt_info (VTOC_READ).seek_count + devtab.opt_info (VTOC_WRITE).seek_count; end; end; dkio = cur_dkio - prev_dkio; prev_dkio = cur_dkio; vtio = cur_vtio - prev_vtio; prev_vtio = cur_vtio; return; %page; %include dskdcl; end;  spg_ring_0_info_.pl1 06/04/84 1617.6rew 06/04/84 1242.7 24732 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* Procedure to return the virtual cpu time spent in the main gates into ring zero */ /* Last Modified: (Date and Reason) 09/22/76 Noel I. Morris to use new get_gate_data_ 07/09/75 Steve Webber to work with combined linkage segments for gates 10/27/73 Steve Webber to take into account call limiter type gates. */ /* ****************************************************** * * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * * * ****************************************************** */ spg_ring_0_info_: proc (time); /* Parameters */ dcl time fixed bin (52); /* Automatic */ dcl code fixed bin (35); /* error code */ dcl i fixed bin; /* gate index */ dcl j fixed bin; /* entry index */ dcl nentries fixed bin; /* number of gate entries */ dcl 1 table (512) like gate_table aligned; /* table of gate information */ /* Static */ dcl tempp ptr static init (null ()); dcl gate_name (6) char (32) static options (constant) init ( "hcs_", "hphcs_", "ioi_", "netp_", "net_", "phcs_"); /* Based */ dcl 1 info based aligned, /* metering info in gate */ 2 cpu_time fixed bin (52), /* CPU time spent in gate entry */ 2 vcpu_time fixed bin (52), /* virtual CPU time spent in gate entry */ 2 page_waits fixed bin, /* number of page waits in gate entry */ 2 calls fixed bin; /* number of calls to gate entry */ /* Entries */ dcl get_gate_data_ entry (char (*), 1 dim (*) like gate_table aligned, fixed bin, ptr, bit (1) aligned, fixed bin (35)), hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); dcl (hbound, null) builtin; % include gate_data; time = 0; /* start out with no time spent */ if tempp = null () then do; call hcs_$make_seg ("", "spg_ring_0_info_.temp", "", 01010b, tempp, code); if code ^= 0 then return; end; do i = 1 to hbound (gate_name, 1); call get_gate_data_ (gate_name (i), table, nentries, tempp, "1"b, code); if code = 0 then do j = 1 to nentries; time = time + table (j).datap -> gate_entry_data.vcpu_time; end; end; return; end;  spg_util_.pl1 01/26/85 1315.2r w 01/22/85 1313.9 51516 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* Program to prepare metering information for SPG program. This program uses buffers set up by meter_util_ as called by spg itself. These buffers are refernecd via the unique index passed to this program through the reset entry. Modified March 1981 by J. Bongiovanni to fix segfault time computation Modified November 1984 by M. Pandolf to include hc_lock. */ /* ****************************************************** * * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * * * ****************************************************** */ spg_util_: proc (pzi, pnmpi, pmpi, pint, ptc, ppf, psf, puse_rz, px, string, length, chsw); dcl pzi float bin, /* % zero idle time */ pnmpi float bin, /* % nmp idle time */ pmpi float bin, /* % mp idle time */ pint float bin, /* % interrupt time */ ptc float bin, /* % time in traffic controller */ ppf float bin, /* % page fault time */ psf float bin, /* % segfault time */ puse_rz float bin, /* % time in ring 0 */ px float bin, /* % paging interrupt time */ string char (110), /* returned output string */ length fixed bin, /* length of string */ chsw fixed bin (1); /* nonzero if output to be printed */ dcl unique fixed bin int static; dcl (sstp1, sstp2, tcdp1, tcdp2) ptr static; dcl time_rz fixed bin (52), (meter_time, n_pf, n_pf_sf, time_int_xd, time_pf, time_sf, time_tc) float; dcl spg_ring_0_info_ entry (fixed bin (52)); dcl ioa_$rsnnl entry options (variable); dcl 1 cf aligned, /* config and tuning data */ 2 nproc fixed bin, /* number of CPUs */ 2 nused fixed bin (18), /* number of main memory pages used */ 2 min_eligible fixed bin (30), /* min number of eligible processes */ 2 max_eligible fixed bin (30), /* max number of eligible processes */ 2 working_set_addend fixed bin (18), /* additive working set parameter */ 2 working_set_factor fixed bin (35, 18), /* working set factor */ 2 tefirst fixed bin (30), /* first eligible time */ 2 telast fixed bin (30), /* last eligible time */ 2 timax fixed bin (35); /* time in queue for lowest level */ dcl 1 iscf static aligned like cf; /* static copy of config and tuning data */ dcl (divide, float, unspec) builtin; /* check if configuration or tuning has changed */ cf.nproc = tcdp2 -> tcm.ncpu; cf.nused = sstp2 -> sst.nused; cf.min_eligible = tcdp2 -> tcm.min_eligible; cf.max_eligible = tcdp2 -> tcm.max_eligible; cf.working_set_addend = tcdp2 -> tcm.working_set_addend; cf.working_set_factor = tcdp2 -> tcm.working_set_factor; cf.tefirst = tcdp2 -> tcm.tefirst; cf.telast = tcdp2 -> tcm.telast; cf.timax = tcdp2 -> tcm.timax; chsw = 0; if unspec (cf) ^= unspec (iscf) then do; /* If data changed ... */ chsw = 1; /* set switch. */ call ioa_$rsnnl ( "^7xcpu= ^d, pages= ^d, min_e= ^d, max_e= ^d, wsa= ^d, wsf= ^.2f, tefirst= ^5.2f, telast= ^5.2f, timax= ^5.2f.", string, length, cf.nproc, cf.nused, divide (cf.min_eligible, 262144, 17, 0), divide (cf.max_eligible, 262144, 17, 0), cf.working_set_addend, float (cf.working_set_factor, 27), cf.tefirst * 1.e-6, cf.telast * 1.e-6, cf.timax * 1.e-6); unspec (iscf) = unspec (cf); /* Save new data. */ end; /* determine basic metering period */ if tcdp2 -> tcm.processor_time = tcdp1 -> tcm.processor_time then do; /* probably no access to ring-0 */ pzi, pnmpi, pmpi, pint, ptc, ppf, psf, puse_rz, px = 0.0; return; end; meter_time = (tcdp2 -> tcm.processor_time - tcdp1 -> tcm.processor_time) * 1.e-2; /* compute idle times */ pzi = (tcdp2 -> tcm.zero_idle - tcdp1 -> tcm.zero_idle) / meter_time; pnmpi = (tcdp2 -> tcm.nmp_idle - tcdp1 -> tcm.nmp_idle) / meter_time; pmpi = (tcdp2 -> tcm.mp_idle - tcdp1 -> tcm.mp_idle + tcdp2 -> tcm.loading_idle - tcdp1 -> tcm.loading_idle) / meter_time; /* compute info on interrupts, traffic controller, page faults, segment faults, and ring zero usage */ time_int_xd = tcdp2 -> tcm.interrupt_time - tcdp1 -> tcm.interrupt_time; pint = time_int_xd / meter_time; px = 0.0; /* No diferentiation for paging interrupts */ time_tc = (tcdp2 -> tcm.getwork_time - tcdp1 -> tcm.getwork_time); ptc = time_tc / meter_time; time_pf = tcdp2 -> tcm.cpu_pf_time - tcdp1 -> tcm.cpu_pf_time; n_pf = tcdp2 -> tcm.cpu_pf_count - tcdp1 -> tcm.cpu_pf_count; n_pf_sf = sstp2 -> sst.total_sf_pf - sstp1 -> sst.total_sf_pf; ppf = time_pf / meter_time; time_sf = sstp2 -> sst.cpu_sf_time - sstp1 -> sst.cpu_sf_time; psf = time_sf / meter_time; call spg_ring_0_info_ (time_rz); puse_rz = time_rz / meter_time; return; /* reset entry point */ reset: entry (unique_a, sstp1_a, sstp2_a, tcdp1_a, tcdp2_a); dcl unique_a fixed bin, (sstp1_a, sstp2_a, tcdp1_a, tcdp2_a) ptr; unique = unique_a; /* copy args */ sstp1 = sstp1_a; sstp2 = sstp2_a; tcdp1 = tcdp1_a; tcdp2 = tcdp2_a; unspec (iscf) = "0"b; return; % include tcm; %include hc_lock; % include sst; end;  system_performance_graph.pl1 01/26/85 1315.2r w 01/22/85 1313.9 92268 /* *********************************************************** * * * Copyright, (C) Honeywell Information Systems Inc., 1982 * * * *********************************************************** */ /* * meter plotting command f.j. corbat'o, Jan. 1970, modified April 1970, modified April 1971 Last modified January 1981 by J. Bongiovanni to fix minor bugs Modified November 1984 by M. Pandolf to include hc_lock. */ /* ****************************************************** * * * * * Copyright (c) 1972 by Massachusetts Institute of * * Technology and Honeywell Information Systems, Inc. * * * * * ****************************************************** */ system_performance_graph: spg: proc; dcl (mn, nn, mu, nu) fixed bin; dcl ss char (arglen) based (argp); dcl arglen fixed bin; dcl argp ptr; dcl ct fixed bin static; dcl short_lines bit (1) int static init ("0"b); dcl llen fixed bin; dcl unique fixed bin static init (0); dcl first_time bit (1) aligned static init ("1"b); dcl (i, length, chsw, qc) fixed bin (17); dcl code fixed bin (35); dcl (sstp1, sstp2, tcdp1, tcdp2) ptr static; dcl (pzi, pnmpi, pmpi, pint, ptc, ppf, psf, puse_rz, px, meter_time) float; dcl (pdio, dkio, vtio) fixed bin; dcl (time, wakeup_time) fixed bin (52); dcl minute_time fixed bin (35); dcl chname fixed bin (71) int static init (0); dcl str char (24); dcl 1 st aligned, (2 hour pic "99", 2 min pic "99.v99", 2 blank char (1), 2 graph char (101)) unal; dcl cstring char (110) aligned; dcl mplot_mode bit (1) aligned; dcl mplot_switch ptr static init (null()); dcl outfilename char (168) var; dcl (k, arg_count) fixed bin; dcl month fixed bin, dom fixed bin, tod fixed bin (52), year fixed bin, dow fixed bin, hour fixed bin (35), minute float bin, zone char (3) aligned; dcl iox_$user_output ptr ext, error_table_$badopt fixed bin (35) ext; dcl cu_$arg_count entry (fixed bin), cu_$arg_ptr entry (fixed bin, ptr, fixed bin, fixed bin (35)), com_err_ entry options (variable), iox_$attach_ioname entry (char (*), ptr, char (*), fixed bin (35)), iox_$open entry (ptr, fixed bin, bit (1) aligned, fixed bin (35)), iox_$close entry (ptr, fixed bin (35)), iox_$detach_iocb entry (ptr, fixed bin (35)), iox_$control entry (ptr, char(*), ptr, fixed bin(35)), ioa_$ioa_switch entry options (variable), date_time_ entry (fixed bin (52), char (*)), decode_clock_value_ entry (fixed bin (52), fixed bin, fixed bin, fixed bin, fixed bin (52), fixed bin, char (3) aligned), clock_ entry returns (fixed bin (52)), meter_util_$get_buffers entry (fixed bin, ptr, ptr, ptr, ptr, fixed bin (35)), meter_util_$fill_buffers entry (fixed bin), meter_util_$reset entry (fixed bin), spg_util_$reset entry (fixed bin, ptr, ptr, ptr, ptr), spg_util_ entry (float, float, float, float, float, float, float, float, float, char (110) aligned, fixed bin, fixed bin), spg_fs_info_ entry (fixed bin, fixed bin, fixed bin), system_info_$users entry (fixed bin, fixed bin, fixed bin, fixed bin), ipc_$create_ev_chn entry (fixed bin (71), fixed bin (35)), ipc_$decl_ev_call_chn entry (fixed bin (71), entry, ptr, fixed bin, fixed bin (35)), ipc_$drain_chn entry (fixed bin (71), fixed bin (35)), ipc_$delete_ev_chn entry (fixed bin (71), fixed bin (35)), timer_manager_$alarm_wakeup entry (fixed bin (52), bit (2), fixed bin (71)), timer_manager_$reset_alarm_wakeup entry (fixed bin (71)); dcl (bin, max, min, null, string, substr) builtin; dcl conversion condition; mplot_mode = "0"b; ct = 0; call cu_$arg_count (arg_count); do k = 1 to arg_count; call cu_$arg_ptr (k, argp, arglen, code); if code ^= 0 then go to error; if substr (ss, 1, 1) ^= "-" then do; on conversion goto arg_error; ct = bin (ss, 17); revert conversion; if ct <= 0 then goto arg_error; end; else if ss = "-short" then short_lines = "1"b; else if ss = "-long" | ss = "-lg" then short_lines = "0"b; else if ss = "-output_file" | ss = "-of" then do; mplot_mode = "1"b; call cu_$arg_ptr (k + 1, argp, arglen, code); if (code = 0) & (substr (ss, 1, 1) ^= "-") then do; outfilename = ss; k = k + 1; end; else outfilename = "spg_output"; end; else if ss = "-halt" | ss = "-ht" then go to stop; else do; arg_error: call com_err_ (error_table_$badopt, "spg", ss); return; end; end; if ^first_time then do; call com_err_ (0, "spg", "Already invoked. Use -halt to terminate other invocation"); return; end; if ct = 0 then do; call com_err_ (0, "spg", "Wakeup interval not specified."); return; end; if mplot_mode then do; call iox_$attach_ioname ("spg_output_", mplot_switch, "vfile_ " || outfilename || " -extend", code); if code ^= 0 then go to error; call iox_$open (mplot_switch, 2, "0"b, code); if code ^= 0 then go to error; end; else mplot_switch = iox_$user_output; call date_time_ (clock_ (), str); /* time_stamp output */ call ioa_$ioa_switch (mplot_switch, "^5-^a", str); call meter_util_$get_buffers (unique, sstp1, sstp2, tcdp1, tcdp2, code); call meter_util_$fill_buffers (unique); call spg_util_$reset (unique, sstp1, sstp2, tcdp1, tcdp2); call date_time_ ((tcdp2 -> tcm.initialize_time), str); call ioa_$ioa_switch (mplot_switch, "up= ^20a, sys_hours= ^.1f, cpu_hours= ^.1f", substr (str, 1, 20), (tcdp2 -> tcm.last_time - tcdp2 -> tcm.initialize_time)/36e8, tcdp2 -> tcm.processor_time/36e8); if chname = 0 then do; /* create event channel */ call ipc_$create_ev_chn (chname, code); if code ^= 0 then go to error; call ipc_$decl_ev_call_chn (chname, line, null (), 1, code); if code ^= 0 then go to error; end; else do; call ipc_$drain_chn (chname, code); if code ^= 0 then go to error; end; call line; return; error: call com_err_ (code, "spg", ""); stop: if mplot_switch ^= iox_$user_output & mplot_switch ^= null() then do; call iox_$close (mplot_switch, code); call iox_$detach_iocb (mplot_switch, code); end; mplot_switch = null(); if chname ^= 0 then do; call timer_manager_$reset_alarm_wakeup (chname); call ipc_$delete_ev_chn (chname, code); chname = 0; end; first_time = "1"b; short_lines = "0"b; return; line: entry; /* routine to do a line */ time = clock_ (); call decode_clock_value_ (time, month, dom, year, tod, dow, zone); hour = tod/3.6e9; minute = tod / 6.0e7 - hour * 60; st.hour = hour; st.min = minute; st.blank = " "; st.graph = (11)"| . "; call meter_util_$fill_buffers (unique); call spg_util_ (pzi, pnmpi, pmpi, pint, ptc, ppf, psf, puse_rz, px, cstring, length, chsw); /* * print line if configuration or tuning has changed */ if chsw ^= 0 then call ioa_$ioa_switch (mplot_switch, substr (cstring, 1, length)); call fill_in (pzi + pnmpi + pmpi + pint + ptc + ppf + psf + puse_rz, 0e0, "y"); call fill_in (pzi + pnmpi + pmpi + pint + ptc + ppf, psf, "s"); call fill_in (pzi + pnmpi + pmpi + pint + ptc, ppf, "p"); call fill_in (pzi + pnmpi + pmpi + pint, ptc, "t"); call fill_in (pzi + pnmpi + pmpi, pint, "i"); /* call fill_in (pzi + pnmpi + pmpi + px, 0e0, "x"); NOTE: px not currently being used */ call fill_in (pzi + pnmpi, pmpi, "m"); /* m is mp_idle */ call fill_in (pzi, pnmpi, "*"); /* * is nmp_idle */ call fill_in ((tcdp2 -> tcm.avequeue), 0e0, "q"); call fill_in ((tcdp2 -> tcm.ave_eligible), 0e0, "e"); if (tcdp2 -> tcm.response_count - tcdp1 -> tcm.response_count) ^= 0 then call fill_in ((tcdp2 -> tcm.response_time - tcdp1 -> tcm.response_time) / ((tcdp2 -> tcm.response_count - tcdp1 -> tcm.response_count) * 1e5), 0e0, "r"); if first_time then meter_time = tcdp2 -> tcm.last_time - tcdp2 -> tcm.initialize_time; else meter_time = tcdp2 -> tcm.last_time - tcdp1 -> tcm.last_time; qc = 0; do i = 0 to 5; qc = qc + tcdp2 -> tcm.quit_counts (i) - tcdp1 -> tcm.quit_counts (i); end; call fill_in (qc/ (meter_time/60e6), 0e0, "Q"); call fill_in ((tcdp2 -> tcm.schedulings - tcdp1 -> tcm.schedulings)/ (meter_time/1e7), 0e0, "S"); call spg_fs_info_ (pdio, dkio, vtio); call fill_in (1e2 - pdio / (meter_time / 1e5), 0e0, "P"); /* 1000 max */ call fill_in (1e2 - dkio / (meter_time / 1e5), 0e0, "D"); /* 1000 max */ call fill_in (1e2 - vtio / (meter_time / 1e5), 0e0, "V"); /* 1000 max */ call system_info_$users (mn, nn, mu, nu); call fill_in (nu / 1e1, 0e0, "-"); call fill_in ((nn), 0e0, "+"); if short_lines then llen = 59; else llen = 109; do i = 10 to 90 by 10; /* re-place some "|" for clarity */ if substr (graph, i, 1) = substr (graph, i+2, 1) then if substr (graph, i, 1) = substr (graph, i+1, 1) then substr (graph, i+1, 1) = "|"; end; call ioa_$ioa_switch (mplot_switch, substr (string (st), 1, llen)); minute_time = time/60e6; wakeup_time = (minute_time + ct) * 60000000; call timer_manager_$alarm_wakeup (wakeup_time, "00"b, chname); if ^first_time then call iox_$control (mplot_switch, "start", null (), code); call meter_util_$reset (unique); first_time = "0"b; return; /* internal procedure */ fill_in: proc (x, delx, token); dcl (x, delx) float, token char (1) aligned; dcl (i1, i2) fixed bin; if ^short_lines then do; i1 = max (min (bin (x + .5e0, 17), 100), 0); i2 = max (min (bin (x + delx + .5e0, 17), 100), 0); end; else do; i1 = max (min (bin (x*.5e0 + .5e0, 17), 50), 0); i2 = max (min (bin ((x + delx)*.5e0 + .5e0, 17), 50), 0); end; do i = i1 to i2; substr (st.graph, i + 1, 1) = token; end; return; end fill_in; % include tcm; % include hc_lock; end; bull_copyright_notice.txt 08/30/05 1008.4r 08/30/05 1007.3 00020025 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group Bull including Bull HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell Bull Inc., Groupe Bull and Bull HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato.Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, Bull or Bull HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by Bull HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved