COMPILATION LISTING OF SEGMENT cache_meters Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 04/26/84 1324.2 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 /* format: style4,delnl,insnl,ifthenstmt,indnoniterend,ifthendo,ifthen,^thendo */ 10 11 /* Written October 1983 by R. Coppola to display cache error counters */ 12 /* Modified: 2/15/84 by Greg Texada to add cache_meters_$for_monitor */ 13 14 cache_meters: 15 proc; 16 17 /* Automatic */ 18 19 dcl INX fixed bin; 20 dcl (all_sw, subroutine) bit (1); 21 dcl argc fixed bin (21); /* character index into current arg */ 22 dcl argl fixed bin (21); 23 dcl argp ptr; 24 dcl brief_sw bit (1); 25 dcl code fixed bin (35); 26 dcl cpu_string bit (MAX_CPUS) aligned; 27 dcl (cur_ptr, prev_ptr) (1) ptr; 28 dcl meter_cur (1) ptr; 29 dcl 1 cache_counters (MAX_CPUS) aligned, 30 2 cpu_tag fixed bin (35), 31 2 cache_type fixed bin (35), /* 0 = L68, no cache 32* 1 = L68, 2K 33* 2 = DPS8, 8k 34* 3 = VSSC, 8k 35* 4 = VSSC, 16k 36* 5 = VSSC, 32k */ 37 2 cache_err_ctrs (17) fixed bin (35); 38 dcl do_totals bit (1); 39 dcl field_count fixed bin (35); 40 dcl formatted_time (MAX_CPUS) char (10); 41 dcl found_name bit (1); 42 dcl got_cpu (MAX_CPUS + 1) bit (1); 43 dcl had_output bit (1); 44 dcl have_ctrs bit (1); 45 dcl (i, ii) fixed bin; 46 dcl j fixed bin; 47 dcl k fixed bin; 48 dcl l fixed bin; 49 dcl 1 line unal, 50 2 title char (31), 51 2 field (9) char (12); 52 dcl line_length fixed bin (17); 53 dcl long bit (1); 54 dcl meter_time (MAX_CPUS) fixed bin (71); 55 dcl nargs fixed bin; 56 dcl ncpus fixed bin; 57 dcl nprint fixed bin; 58 dcl pic12 picture "zzzzzzzzzzz9"; 59 dcl meter_prev (1) ptr; 60 dcl print_fault (32) bit (1); 61 dcl report bit (1); 62 dcl reset bit (1); 63 dcl single_fault_index fixed bin; 64 dcl sort bit (1); 65 dcl temp_sw bit (1) init ("0"b); 66 dcl total_err_ctrs (17) fixed bin (35); 67 dcl total_sw bit (1); 68 dcl totals_only bit (1); 69 70 71 /* Static */ 72 73 dcl CPU_TAGS char (16) int static options (constant) init ("ABCDEFGHabcdefgh"); 74 dcl meter_unique (8) fixed bin int static init (0, 0, 0, 0, 0, 0, 0, 0); 75 76 dcl my_name char (12) init ("cache_meters") int static options (constant); 77 dcl entry_names (8) char (25) int static options (constant) 78 init ("cpu_a_cache_err_ctr_array", "cpu_b_cache_err_ctr_array", "cpu_c_cache_err_ctr_array", 79 "cpu_d_cache_err_ctr_array", "cpu_e_cache_err_ctr_array", "cpu_f_cache_err_ctr_array", 80 "cpu_g_cache_err_ctr_array", "cpu_h_cache_err_ctr_array"); 81 82 /* Based */ 83 84 dcl arg char (argl) based (argp); 85 86 dcl 1 prev_cache_ctrs (1) like cur_cache_ctrs based (prev_ptr (1)), 87 1 cur_cache_ctrs (1) based (cur_ptr (1)), 88 2 cache_type fixed bin (35), /* 0 = L68, no cache 89* 1 = L68, 2K 90* 2 = DPS8, 8k 91* 3 = VSSC, 8k 92* 4 = VSSC, 16k 93* 5 = VSSC, 32k */ 94 2 cache_err_ctrs (17) fixed bin (35); 95 96 97 98 /* Entry */ 99 100 dcl com_err_ entry options (variable); 101 dcl cu_$arg_count entry (fixed bin); 102 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 103 dcl get_line_length_$switch entry (ptr, fixed bin (35)) returns (fixed bin); 104 dcl ioa_ entry options (variable); 105 dcl metering_util_$define_regions entry options (variable); 106 dcl metering_util_$fill_buffers entry (fixed bin, fixed bin (71), char (*), (*) ptr, (*) ptr, fixed bin (35)); 107 dcl metering_util_$reset entry (fixed bin, fixed bin (35)); 108 109 /* External */ 110 111 dcl error_table_$bad_arg fixed bin (35) external; 112 dcl error_table_$badopt fixed bin (35) external; 113 114 115 116 /* Pick up and validate each argument */ 117 118 ncpus = 0; 119 totals_only, total_sw = "1"b; /* default */ 120 subroutine, all_sw, brief_sw, cpu_string, do_totals, had_output, long, report, reset, sort, got_cpu (*) = "0"b; 121 call cu_$arg_count (nargs); 122 do i = 1 to nargs; 123 call cu_$arg_ptr (i, argp, argl, code); 124 125 if arg = "-report" then report = "1"b; 126 else if arg = "-reset" | arg = "-rs" then reset = "1"b; 127 else if arg = "-report_reset" | arg = "-rr" then do; 128 report = "1"b; 129 reset = "1"b; 130 end; 131 132 else if arg = "-brief" | arg = "-bf" then brief_sw = "1"b; 133 134 else if arg = "-tt" | arg = "-total" then do_totals = "1"b; 135 136 else if arg = "-cpu" then do; 137 call cu_$arg_ptr (i + 1, argp, argl, code); 138 if code ^= 0 then do; 139 if (i + 1) > nargs then do; /* user wants ALL cpus */ 140 do_all_cpus: 141 do j = 1 to MAX_CPUS; 142 substr (cpu_string, j, 1) = "1"b; 143 end; 144 go to done_cpu_arg; 145 end; 146 147 else do; 148 call com_err_ (code, my_name, ""); 149 return; 150 end; 151 end; 152 else if substr (arg, 1, 1) = "-" then goto do_all_cpus; 153 154 i = i + 1; 155 156 if argl > 8 then do; 157 call com_err_ (0, my_name, "Too many CPUs specified (^a).", arg); 158 return; 159 end; 160 161 if verify (arg, CPU_TAGS) ^= 0 then do; 162 call com_err_ (0, my_name, "Invalid CPU Tag(s) ^a", arg); 163 return; 164 end; 165 do argc = 1 to argl; 166 substr (cpu_string, mod (index (CPU_TAGS, substr (arg, argc, 1)) - 1, 8) + 1, 1) = "1"b; 167 end; 168 done_cpu_arg: 169 totals_only = "0"b; 170 total_sw = "0"b; 171 end; 172 173 else do; 174 call com_err_ (error_table_$badopt, my_name, arg); 175 return; 176 end; 177 end; 178 code = 0; 179 call init (meter_unique); 180 if code ^= 0 then return; 181 182 if ^report & ^reset then report = "1"b; /* default is -report */ 183 if do_totals then total_sw = "1"b; 184 185 if report then do; /* how many CPUs per line? */ 186 line_length = get_line_length_$switch (null (), code); 187 if line_length < 132 then 188 line_length = 4; 189 else line_length = 9; 190 if code ^= 0 then line_length = 9; 191 code = 0; 192 call accum_meters (meter_unique); 193 if code ^= 0 then return; 194 195 if total_sw then do; /* fill in TOTALs array */ 196 if ^totals_only then ncpus = ncpus + 1; 197 cache_counters (ncpus).cpu_tag = MAX_CPUS + 1; 198 cache_counters (ncpus).cache_type = 0; 199 do i = 1 to 17; 200 cache_counters (ncpus).cache_err_ctrs (i) = total_err_ctrs (i); 201 if total_err_ctrs (i) ^= 0 then got_cpu (ncpus) = "1"b; 202 end; 203 end; 204 call ioa_ ("^/Total Metering Time:^-^a^/", formatted_time (1)); 205 206 do i = 1 to ncpus + 1 by line_length; /* max of 4/9 cpus per screen */ 207 nprint = min (line_length, ncpus + 1 - i); 208 if i >= nprint then 209 l = ncpus; 210 else l = nprint; 211 have_ctrs = "0"b; 212 do j = i to l while (have_ctrs = "0"b); 213 if got_cpu (j) then have_ctrs = "1"b; 214 end; 215 if ^have_ctrs then goto try_next_set; 216 had_output = "1"b; /* printed something */ 217 string (line) = ""; 218 line.title = "CPU Tag"; 219 do j = 1 to nprint; 220 INX = (i + j - 1); 221 if cache_counters (INX).cpu_tag ^= MAX_CPUS + 1 then 222 line.field (j) = " " || CPU_NAMES (cache_counters (INX).cpu_tag); 223 else line.field (j) = " ALL"; 224 end; 225 call ioa_ ("^a", string (line)); 226 string (line) = ""; 227 228 line.title = "Cache Type"; 229 do j = 1 to nprint; 230 INX = (i + j - 1); 231 if cache_counters (INX).cpu_tag ^= MAX_CPUS + 1 then 232 line.field (j) = " " || CACHE_TYPES (cache_counters (INX).cache_type); 233 else line.field (j) = ""; 234 end; 235 call ioa_ ("^a", string (line)); 236 237 do k = 1 to NO_CACHE_ERR_TYPES; 238 string (line) = ""; 239 field_count = 0; 240 if k = 2 then do; 241 line.title = "DPS8 Write Notify Counters"; 242 call ioa_ ("^/^a", string (line)); 243 end; 244 245 line.title = CACHE_ERROR_NAME (k); 246 247 do j = 1 to nprint; 248 INX = (i + j - 1); 249 field_count = field_count + cache_counters (INX).cache_err_ctrs (k); 250 pic12 = cache_counters (INX).cache_err_ctrs (k); 251 line.field (j) = pic12; 252 end; 253 if brief_sw = "1"b then 254 if field_count = 0 then go to skip_it; 255 call ioa_ ("^a", string (line)); 256 skip_it: 257 end; 258 call ioa_ ("^/"); 259 try_next_set: 260 end; 261 if ^had_output then 262 call ioa_ ("^/All cache counters ^[for selected CPU'S ^]were equal to zero.", ^totals_only); 263 end; 264 265 if reset then do; 266 do i = 1 to MAX_CPUS; 267 call metering_util_$reset (meter_unique (i), code); 268 if code ^= 0 then call com_err_ (code, my_name, "Resetting"); 269 end; 270 end; 271 return; 272 273 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 274 275 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 276 277 278 cache_meters_$for_monitor: 279 entry (a_cache_counters_ptr, a_ncpus, a_code); 280 281 282 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 283 /* */ 284 /* This entry provides a method for monitor_cache to get the cache memory errors that */ 285 /* occured between calls. */ 286 /* */ 287 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 288 289 290 dcl a_cache_counters_ptr ptr, 291 a_ncpus fixed bin, 292 a_code fixed bin (35), 293 ( 294 monitor_cur (1), 295 monitor_prev (1) 296 ) ptr, 297 monitor_unique (8) fixed bin int static init (0, 0, 0, 0, 0, 0, 0, 0), 298 1 a_cache_counters (MAX_CPUS) like cache_counters aligned based (a_cache_counters_ptr); 299 300 a_ncpus, ncpus, code, a_code = 0; 301 subroutine = "1"b; 302 cpu_string = (8)"1"b; /* do em all */ 303 totals_only = "0"b; 304 call init (monitor_unique); 305 if code ^= 0 then goto RETURN; 306 call accum_meters (monitor_unique); 307 if code ^= 0 then goto RETURN; 308 if a_cache_counters_ptr ^= null () then do; /* if null, then is first "init" call */ 309 a_cache_counters (*) = cache_counters (*); /* give caller the data */ 310 a_ncpus = ncpus; 311 end; 312 do i = 1 to MAX_CPUS; /* reset for interval calls */ 313 call metering_util_$reset (monitor_unique (i), (0)); 314 end; 315 RETURN: 316 a_code = code; 317 return; 318 319 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 320 321 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 322 323 324 init: 325 proc (munique); 326 327 /* Initialize if this is the first call */ 328 329 dcl munique (8) fixed bin parameter; 330 331 do i = 1 to MAX_CPUS; 332 if munique (i) = 0 then do; 333 call metering_util_$define_regions (munique (i), code, "wired_hardcore_data", entry_names (i), 18); 334 if code ^= 0 then 335 if ^subroutine then call com_err_ (code, my_name, "Initializing"); 336 end; 337 end; 338 end init; 339 340 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 341 342 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 343 344 345 accum_meters: 346 proc (munique); 347 348 dcl munique (8) fixed bin parameter; 349 350 351 total_err_ctrs (*) = 0; 352 353 if totals_only then ncpus = 1; 354 do i = 1 to MAX_CPUS; 355 call metering_util_$fill_buffers (munique (i), meter_time (i), formatted_time (i), cur_ptr, prev_ptr, code) 356 ; 357 if code ^= 0 then do; 358 if ^subroutine then call com_err_ (code, my_name, "Filling buffers"); 359 return; 360 end; 361 362 if cur_cache_ctrs (1).cache_type = L68_NONE then goto try_next_cpu; 363 if (^subroutine) 364 & (sum (cur_cache_ctrs (1).cache_err_ctrs (*)) - sum (prev_cache_ctrs (1).cache_err_ctrs (*)) = 0) 365 then /* the subroutine needs ALL data, even zero counters */ 366 goto try_next_cpu; 367 if substr (cpu_string, i, 1) | total_sw then do; 368 if ^totals_only then ncpus = ncpus + 1; 369 got_cpu (ncpus) = "1"b; 370 cache_counters (ncpus).cpu_tag = i; 371 cache_counters (ncpus).cache_type = cur_cache_ctrs (1).cache_type; 372 373 do j = 1 to 17; 374 cache_counters (ncpus).cache_err_ctrs (j) = 375 cur_cache_ctrs (1).cache_err_ctrs (j) - prev_cache_ctrs (1).cache_err_ctrs (j); 376 377 total_err_ctrs (j) = total_err_ctrs (j) + cache_counters (ncpus).cache_err_ctrs (j); 378 end; 379 if (^totals_only) & (^subroutine) then /* the subroutine needs ALL data, even zero counters */ 380 if substr (cpu_string, i, 1) = "0"b then do; 381 /* if this wasn't selected, undo it */ 382 ncpus = ncpus - 1; 383 got_cpu (ncpus) = "0"b; 384 end; 385 end; 386 try_next_cpu: 387 end; 388 389 end accum_meters; 390 1 1 /* START OF: fim_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 1 2 1 3 /* Declarations useful for programs which interpret the per-cpu fault and cache 1 4* error counter data maintained in wired_hardcore_data$cpu_X_flt_ctr_array and 1 5* wired_hardcore_data$cpu_X_cache_err_ctr_array. The fault counters are an 1 6* array of counts by fault number, where the first NO_HARDWARE_FAULTS 1 7* fault numbers correspond to hardware faults, and the remaining 1 8* correspond to sub-cases of hardware faults, as defined procedurally in 1 9* fim. The per-cpu cache error counters are simply an array of error counters. 1 10* The cache error counter array is defined as: location ZERO contains the 1 11* cache size/type and is filled in by init_processor;location 1 thru 12 hold 1 12* the error counters as filled in by fim_util or page_fault. 1 13* 1 14* Written March 1981 by J. Bongiovanni */ 1 15 /* Modified July 1981 by M. Weaver for undefined_pointer 1 16* Modified October 1983 by Rich Coppola for support of per-processor fault and cache counters. 1 17**/ 1 18 1 19 dcl MAX_CPUS fixed bin init (8) int static options (constant); 1 20 /* current maximum of CPU numbers */ 1 21 1 22 dcl CPU_NAMES (8) char (1) int static options (constant) init ( 1 23 "A", "B", "C", "D", "E", "F", "G", "H"); 1 24 dcl (NO_HARDWARE_FAULTS init (32), NO_TOTAL_FAULTS init (128)) 1 25 fixed bin int static options (constant); 1 26 1 27 dcl EXTANT_FAULT (32) bit (1) unaligned init ((26) (1)"1"b, (5) (1)"0"b, "1"b) 1 28 int static options (constant); /* by hardware fault no. "1"=> valid */ 1 29 1 30 dcl LONG_FAULT_NAME (128) char (30) init /* full names of faults */ 1 31 /* begin of hardware faults */ 1 32 ("shutdown", "store", "mme1", "fault_tag_1", "timer_runout", 1 33 "command", "derail", "lockup", "connect", "parity", 1 34 "illegal_procedure", "op_not_complete", "startup", 1 35 "overflow", "divide_check", "execute", "segment_fault", 1 36 "page_fault", "directed_fault_2", "directed_fault_3", 1 37 "access_violation", "mme2", "mme3", "mme4", "linkage_fault", 1 38 "fault_tag_3", (5) (1)"", "trouble", 1 39 /* begin of subordinate faults */ 1 40 "illegal_opcode", "null_pointer", "illegal_modifier", "illegal_ring_order", 1 41 "not_in_execute_bracket", "no_execute_permission", "not_in_read_bracket", 1 42 "no_read_permission", "not_in_write_bracket", "no_write_permission", 1 43 "not_a_gate", "not_in_call_bracket", "outward_call", "bad_outward_call", 1 44 "inward_return", "cross_ring_transfer", "ring_alarm_fault", "am_fault", 1 45 "out_of_bounds", "fixedoverflow", "overflow", "underflow", "stringsize", 1 46 "illegal_procedure", "stack_out_of_bounds", "packed_pointer_fault", 1 47 "lot_fault", "isot_fault", "system_packed_pointer", (4) (1)" ", 1 48 "size", "neti", "command", "sus_", "trm_", "wkp_", "undefined_pointer", (56) (1)" ") 1 49 1 50 int static options (constant); 1 51 1 52 dcl SHORT_FAULT_NAME (32) char (3) init /* short names of hardware faults */ 1 53 ("sdf", "str", "mme", "ft1", "tro", "cmd", "drl", "luf", 1 54 "con", "par", "ipr", "onc", "suf", "ovf", "div", "exf", 1 55 "df0", "df1", "df2", "df3", "acv", (3) (1)" ", "ft2", 1 56 "ft3", (5) (1)" ", "trb") int static options (constant); 1 57 1 58 1 59 /* The following table is used to thread subordinate (non-hardware known) 1 60* faults to primary (hardware known) fault types. Its existence and 1 61* contents depends on the way fim handles faults, and it corresponds 1 62* roughly to fault_table in fim. This table is an array of threads by 1 63* fault number. To follow a thread for a hardware fault, use the 1 64* value of this table indexed by hardware fault number to find the 1 65* first subordinate fault number (0=>none). Continue for the subordinate 1 66* fault until a thread of 0 is encountered. */ 1 67 1 68 dcl THREAD_FAULT (128) fixed bin int static options (constant) init ( 1 69 0, 0, 0, 0, 0, 58, 0, 0, 0, 0, 1 70 33, 0, 0, 52, 0, 0, 0, 0, 0, 0, 1 71 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 72 0, 0, 35, 36, 56, 37, 38, 39, 40, 41, 1 73 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 1 74 57, 53, 54, 55, 66, 0, 72, 59, 60, 61, 1 75 68, (67) 0); 1 76 1 77 1 78 dcl CACHE_TYPES (0:5) char (9) int static options (constant) init ( 1 79 "L68_NONE", " L68_2K", " DPS8_8K", " VSSC_8K", "VSSC_16K", "VSSC_32K"); 1 80 1 81 1 82 /* The cache size is placed in the first word of the per-processor array 1 83*by init_processor. The following declarations list the currently known sizes 1 84*and their decodes */ 1 85 1 86 dcl L68_NONE fixed bin int static options (constant) init (0), 1 87 L68_2K fixed bin int static options (constant) init (1), 1 88 DPS8_8K fixed bin int static options (constant) init (2), 1 89 VSSC_8K fixed bin int static options (constant) init (3), 1 90 VSSC_16K fixed bin int static options (constant) init (4), 1 91 VSSC_32K fixed bin int static options (constant) init (5); 1 92 1 93 dcl NO_CACHE_ERR_TYPES fixed bin int static options (constant) init (12); 1 94 1 95 1 96 /* Note PFR = Primary Fault Reg (L68/DPS8), EFR = Extended Fault Reg (DPS8) */ 1 97 1 98 dcl CACHE_ERROR_NAME (12) char (32) var int static options (constant) init ( 1 99 "Primary Dir Parity/MultiMatch", /* Cell 1; PFR Bit 32 */ 1 100 "PT A Buffer OVFL/PAR/SEQ Err", /* Cell 2; EFR Bit 36 */ 1 101 "PT B Buffer OVFL/PAR/SEQ Err", /* Cell 3; EFR Bit 37 */ 1 102 "PT C Buffer OVFL/PAR/SEQ Err", /* Cell 4; EFR Bit 38 */ 1 103 "PT D Buffer OVFL/PAR/SEQ Err", /* Cell 5; EFR Bit 39 */ 1 104 "Primary DIR/PT Buffer OVFL", /* Cell 6; EFR Bit 40 */ 1 105 "WNO Parity ANY Port", /* Cell 7; EFR Bit 41 for DPS8 (cache type = 2) ONLY */ 1 106 /* NOTE: This counter is NOT USED by the VS&SC Cache, 1 107* ONLY the 8k model CPU */ 1 108 "Level 0 Dup Dir Parity", /* Cell 8; EFR Bit 42 */ 1 109 "Level 1 Dup Dir Parity", /* Cell 9; EFR Bit 43 */ 1 110 "Level 2 Dup Dir Parity", /* Cell 10; EFR Bit 44 */ 1 111 "Level 3 Dup Dir Parity", /* Cell 10; EFR Bit 45 */ 1 112 "Dup Dir MultiMatch"); 1 113 /* Cell 11; EFR Bit 46 */ 1 114 1 115 1 116 /* END OF: fim_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 392 393 394 end cache_meters; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/26/84 1319.8 cache_meters.pl1 >special_ldd>on>gt>cache_meters.pl1 391 1 10/28/83 1424.1 fim_meters.incl.pl1 >ldd>include>fim_meters.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. CACHE_ERROR_NAME 000000 constant varying char(32) initial array dcl 1-98 ref 245 CACHE_TYPES 000154 constant char(9) initial array unaligned dcl 1-78 ref 231 CPU_NAMES 000172 constant char(1) initial array unaligned dcl 1-22 ref 221 CPU_TAGS 000261 constant char(16) initial unaligned dcl 73 ref 161 166 INX 000100 automatic fixed bin(17,0) dcl 19 set ref 220* 221 221 230* 231 231 248* 249 250 L68_NONE constant fixed bin(17,0) initial dcl 1-86 ref 362 MAX_CPUS constant fixed bin(17,0) initial dcl 1-19 ref 26 29 40 42 54 140 197 221 231 266 309 312 331 354 NO_CACHE_ERR_TYPES constant fixed bin(17,0) initial dcl 1-93 ref 237 a_cache_counters based structure array level 1 dcl 290 set ref 309* a_cache_counters_ptr parameter pointer dcl 290 ref 278 308 309 a_code parameter fixed bin(35,0) dcl 290 set ref 278 300* 315* a_ncpus parameter fixed bin(17,0) dcl 290 set ref 278 300* 310* all_sw 000101 automatic bit(1) unaligned dcl 20 set ref 120* arg based char unaligned dcl 84 set ref 125 126 126 127 127 132 132 134 134 136 152 157* 161 162* 166 174* argc 000103 automatic fixed bin(21,0) dcl 21 set ref 165* 166* argl 000104 automatic fixed bin(21,0) dcl 22 set ref 123* 125 126 126 127 127 132 132 134 134 136 137* 152 156 157 157 161 162 162 165 166 174 174 argp 000106 automatic pointer dcl 23 set ref 123* 125 126 126 127 127 132 132 134 134 136 137* 152 157 161 162 166 174 brief_sw 000110 automatic bit(1) unaligned dcl 24 set ref 120* 132* 253 cache_counters 000116 automatic structure array level 1 dcl 29 set ref 309 cache_err_ctrs 1 based fixed bin(35,0) array level 2 in structure "prev_cache_ctrs" dcl 86 in procedure "cache_meters" ref 363 374 cache_err_ctrs 2 000116 automatic fixed bin(35,0) array level 2 in structure "cache_counters" dcl 29 in procedure "cache_meters" set ref 200* 249 250 374* 377 cache_err_ctrs 1 based fixed bin(35,0) array level 2 in structure "cur_cache_ctrs" dcl 86 in procedure "cache_meters" ref 363 374 cache_type 1 000116 automatic fixed bin(35,0) array level 2 in structure "cache_counters" dcl 29 in procedure "cache_meters" set ref 198* 231 371* cache_type based fixed bin(35,0) array level 2 in structure "cur_cache_ctrs" dcl 86 in procedure "cache_meters" ref 362 371 code 000111 automatic fixed bin(35,0) dcl 25 set ref 123* 137* 138 148* 178* 180 186* 190 191* 193 267* 268 268* 300* 305 307 315 333* 334 334* 355* 357 358* com_err_ 000030 constant entry external dcl 100 ref 148 157 162 174 268 334 358 cpu_string 000112 automatic bit dcl 26 set ref 120* 142* 166* 302* 367 379 cpu_tag 000116 automatic fixed bin(35,0) array level 2 dcl 29 set ref 197* 221 221 231 370* cu_$arg_count 000032 constant entry external dcl 101 ref 121 cu_$arg_ptr 000034 constant entry external dcl 102 ref 123 137 cur_cache_ctrs based structure array level 1 unaligned dcl 86 cur_ptr 000112 automatic pointer array dcl 27 set ref 355* 362 363 371 374 do_totals 000116 automatic bit(1) unaligned dcl 38 set ref 120* 134* 183 entry_names 000174 constant char(25) initial array unaligned dcl 77 set ref 333* error_table_$badopt 000050 external static fixed bin(35,0) dcl 112 set ref 174* field 7(27) 000126 automatic char(12) array level 2 packed unaligned dcl 49 set ref 221* 223* 231* 233* 251* field_count 000117 automatic fixed bin(35,0) dcl 39 set ref 239* 249* 249 253 formatted_time 000120 automatic char(10) array unaligned dcl 40 set ref 204* 355* get_line_length_$switch 000036 constant entry external dcl 103 ref 186 got_cpu 000120 automatic bit(1) array unaligned dcl 42 set ref 120* 201* 213 369* 383* had_output 000120 automatic bit(1) unaligned dcl 43 set ref 120* 216* 261 have_ctrs 000121 automatic bit(1) unaligned dcl 44 set ref 211* 212 213* 215 i 000122 automatic fixed bin(17,0) dcl 45 set ref 122* 123* 137 139 154* 154* 199* 200 200 201* 206* 207 208 212 220 230 248* 266* 267* 312* 313* 331* 332 333 333* 354* 355 355 355 367 370 379* ioa_ 000040 constant entry external dcl 104 ref 204 225 235 242 255 258 261 j 000123 automatic fixed bin(17,0) dcl 46 set ref 140* 142* 212* 213* 219* 220 221 223* 229* 230 231 233* 247* 248 251* 373* 374 374 374 377 377 377* k 000124 automatic fixed bin(17,0) dcl 47 set ref 237* 240 245 249 250* l 000125 automatic fixed bin(17,0) dcl 48 set ref 208* 210* 212 line 000126 automatic structure level 1 packed unaligned dcl 49 set ref 217* 225 225 226* 235 235 238* 242 242 255 255 line_length 000171 automatic fixed bin(17,0) dcl 52 set ref 186* 187 187* 189* 190* 206 207 long 000172 automatic bit(1) unaligned dcl 53 set ref 120* meter_time 000174 automatic fixed bin(71,0) array dcl 54 set ref 355* meter_unique 000010 internal static fixed bin(17,0) initial array dcl 74 set ref 179* 192* 267* metering_util_$define_regions 000042 constant entry external dcl 105 ref 333 metering_util_$fill_buffers 000044 constant entry external dcl 106 ref 355 metering_util_$reset 000046 constant entry external dcl 107 ref 267 313 monitor_unique 000020 internal static fixed bin(17,0) initial array dcl 290 set ref 304* 306* 313* munique parameter fixed bin(17,0) array dcl 348 in procedure "accum_meters" set ref 345 355* munique parameter fixed bin(17,0) array dcl 329 in procedure "init" set ref 324 332 333* my_name 000256 constant char(12) initial unaligned dcl 76 set ref 148* 157* 162* 174* 268* 334* 358* nargs 000174 automatic fixed bin(17,0) dcl 55 set ref 121* 122 139 ncpus 000175 automatic fixed bin(17,0) dcl 56 set ref 118* 196* 196 197 198 200 201 206 207 208 300* 310 353* 368* 368 369 370 371 374 377 382* 382 383 nprint 000176 automatic fixed bin(17,0) dcl 57 set ref 207* 208 210 219 229 247 pic12 000177 automatic picture(12) unaligned dcl 58 set ref 250* 251 prev_cache_ctrs based structure array level 1 unaligned dcl 86 prev_ptr 000114 automatic pointer array dcl 27 set ref 355* 363 374 report 000202 automatic bit(1) unaligned dcl 61 set ref 120* 125* 128* 182 182* 185 reset 000203 automatic bit(1) unaligned dcl 62 set ref 120* 126* 129* 182 265 sort 000204 automatic bit(1) unaligned dcl 64 set ref 120* subroutine 000102 automatic bit(1) unaligned dcl 20 set ref 120* 301* 334 358 363 379 temp_sw 000205 automatic bit(1) initial unaligned dcl 65 set ref 65* title 000126 automatic char(31) level 2 packed unaligned dcl 49 set ref 218* 228* 241* 245* total_err_ctrs 000206 automatic fixed bin(35,0) array dcl 66 set ref 200 201 351* 377* 377 total_sw 000227 automatic bit(1) unaligned dcl 67 set ref 119* 170* 183* 195 367 totals_only 000230 automatic bit(1) unaligned dcl 68 set ref 119* 168* 196 261 303* 353 368 379 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. DPS8_8K internal static fixed bin(17,0) initial dcl 1-86 EXTANT_FAULT internal static bit(1) initial array unaligned dcl 1-27 L68_2K internal static fixed bin(17,0) initial dcl 1-86 LONG_FAULT_NAME internal static char(30) initial array unaligned dcl 1-30 NO_HARDWARE_FAULTS internal static fixed bin(17,0) initial dcl 1-24 NO_TOTAL_FAULTS internal static fixed bin(17,0) initial dcl 1-24 SHORT_FAULT_NAME internal static char(3) initial array unaligned dcl 1-52 THREAD_FAULT internal static fixed bin(17,0) initial array dcl 1-68 VSSC_16K internal static fixed bin(17,0) initial dcl 1-86 VSSC_32K internal static fixed bin(17,0) initial dcl 1-86 VSSC_8K internal static fixed bin(17,0) initial dcl 1-86 error_table_$bad_arg external static fixed bin(35,0) dcl 111 found_name automatic bit(1) unaligned dcl 41 ii automatic fixed bin(17,0) dcl 45 meter_cur automatic pointer array dcl 28 meter_prev automatic pointer array dcl 59 monitor_cur automatic pointer array dcl 290 monitor_prev automatic pointer array dcl 290 print_fault automatic bit(1) array unaligned dcl 60 single_fault_index automatic fixed bin(17,0) dcl 63 NAMES DECLARED BY EXPLICIT CONTEXT. RETURN 002311 constant label dcl 315 ref 305 307 accum_meters 002437 constant entry internal dcl 345 ref 192 306 cache_meters 000527 constant entry external dcl 14 cache_meters_$for_monitor 002141 constant entry external dcl 278 do_all_cpus 000750 constant label dcl 140 ref 152 done_cpu_arg 001155 constant label dcl 168 ref 144 init 002315 constant entry internal dcl 324 ref 179 304 skip_it 002013 constant label dcl 256 ref 253 try_next_cpu 002730 constant label dcl 386 ref 362 363 try_next_set 002030 constant label dcl 259 ref 215 NAMES DECLARED BY CONTEXT OR IMPLICATION. index builtin function ref 166 min builtin function ref 207 mod builtin function ref 166 null builtin function ref 186 186 308 string builtin function set ref 217 225 225 226* 235 235 238* 242 242 255 255 substr builtin function set ref 142 152 166* 166 367 379 sum builtin function ref 363 363 verify builtin function ref 161 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3310 3362 3142 3320 Length 3574 3142 52 175 146 20 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cache_meters 368 external procedure is an external procedure. init internal procedure shares stack frame of external procedure cache_meters. accum_meters internal procedure shares stack frame of external procedure cache_meters. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 meter_unique cache_meters 000020 monitor_unique cache_meters STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cache_meters 000100 INX cache_meters 000101 all_sw cache_meters 000102 subroutine cache_meters 000103 argc cache_meters 000104 argl cache_meters 000106 argp cache_meters 000110 brief_sw cache_meters 000111 code cache_meters 000112 cur_ptr cache_meters 000112 cpu_string cache_meters 000114 prev_ptr cache_meters 000116 cache_counters cache_meters 000116 do_totals cache_meters 000117 field_count cache_meters 000120 formatted_time cache_meters 000120 got_cpu cache_meters 000120 had_output cache_meters 000121 have_ctrs cache_meters 000122 i cache_meters 000123 j cache_meters 000124 k cache_meters 000125 l cache_meters 000126 line cache_meters 000171 line_length cache_meters 000172 long cache_meters 000174 nargs cache_meters 000174 meter_time cache_meters 000175 ncpus cache_meters 000176 nprint cache_meters 000177 pic12 cache_meters 000202 report cache_meters 000203 reset cache_meters 000204 sort cache_meters 000205 temp_sw cache_meters 000206 total_err_ctrs cache_meters 000227 total_sw cache_meters 000230 totals_only cache_meters THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs call_ext_out_desc call_ext_out return alloc_auto_adj bound_check_signal mod_fx1 shorten_stack ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr get_line_length_$switch ioa_ metering_util_$define_regions metering_util_$fill_buffers metering_util_$reset THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 26 000456 29 000465 40 000472 42 000502 54 000511 65 000517 204 000520 355 000522 14 000526 118 000535 119 000536 120 000541 121 000575 122 000604 123 000613 125 000630 126 000641 127 000654 128 000664 129 000666 130 000667 132 000670 134 000703 136 000716 137 000722 138 000742 139 000744 140 000750 142 000757 143 000763 144 000765 148 000766 149 001007 152 001010 154 001015 156 001016 157 001021 158 001054 161 001055 162 001070 163 001124 165 001125 166 001135 167 001153 168 001155 170 001156 171 001157 174 001160 175 001204 177 001205 178 001207 179 001210 180 001217 182 001221 183 001227 185 001233 186 001235 187 001252 189 001260 190 001262 191 001266 192 001267 193 001276 195 001300 196 001302 197 001305 198 001313 199 001314 200 001321 201 001331 202 001337 204 001341 206 001361 207 001402 208 001411 210 001416 211 001417 212 001420 213 001431 214 001440 215 001442 216 001444 217 001446 218 001451 219 001454 220 001463 221 001466 223 001510 224 001516 225 001520 226 001542 228 001545 229 001550 230 001557 231 001562 233 001614 234 001623 235 001625 237 001647 238 001657 239 001662 240 001663 241 001665 242 001670 245 001712 247 001721 248 001731 249 001734 250 001744 251 001754 252 001762 253 001764 255 001771 256 002013 258 002015 259 002030 261 002033 265 002060 266 002062 267 002071 268 002102 269 002132 271 002134 278 002135 300 002147 301 002154 302 002156 303 002163 304 002164 305 002173 306 002175 307 002204 308 002206 309 002213 310 002264 312 002266 313 002275 314 002307 315 002311 317 002314 324 002315 331 002317 332 002327 333 002333 334 002403 337 002434 338 002436 345 002437 351 002441 353 002452 354 002456 355 002465 357 002535 358 002537 359 002566 362 002567 363 002571 367 002627 368 002637 369 002642 370 002647 371 002655 373 002657 374 002665 377 002701 378 002705 379 002707 382 002721 383 002723 386 002730 389 002732 ----------------------------------------------------------- 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