COMPILATION LISTING OF SEGMENT response_meters Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 08/04/87 1255.9 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 /* format: style4 */ 13 response_meters: 14 proc; 15 16 /* response_meters 17* 18* Program to print response time data, summarized by work class. 19* Sufficient access is required to copy out the tc_data header. 20* If the user also has R access to the MGT and the answer table, 21* work class names are printed. 22* 23* Written May 1981 by J. Bongiovanni */ 24 /* 81-12-08 Modified by E. N. Kittlitz. user_table_entry conversion. */ 25 /* Modified November 1984 by M. Pandolf to include hc_lock. */ 26 27 28 /****^ HISTORY COMMENTS: 29* 1) change(87-04-26,GDixon), approve(87-07-13,MCR7741), 30* audit(87-07-27,Hartogs), install(87-08-04,MR12.1-1055): 31* Upgraded for change to answer_table.incl.pl1. 32* END HISTORY COMMENTS */ 33 34 35 /* Automatic */ 36 37 dcl arg_len fixed bin (21); /* length of input argument */ 38 dcl arg_no fixed bin; /* current argument number */ 39 dcl arg_ptr ptr; /* pointer to current argument */ 40 dcl code fixed bin (35); /* standard error code */ 41 dcl cur_ptrs (1) ptr; /* from metering_util_ */ 42 dcl 1 cur_total_wcte aligned like wct_entry; /* dummy WCTE for current totals */ 43 dcl formatted_meter_time char (10); /* total metering time HHHH:MM:SS */ 44 dcl lcg (0:MAX_WORK_CLASS) char (32) varying; /* Load Control Group Names by work class */ 45 dcl meter_calls fixed bin; /* number of calls to meter_response_time */ 46 dcl meter_invalid fixed bin; /* number invalid state transitions */ 47 dcl meter_ovhd float; /* total metering overhead in sec. */ 48 dcl meter_ovhd_call float; /* metering ovrhead per call in msec. */ 49 dcl meter_time fixed bin (71); /* total metering time in microseconds */ 50 dcl n_args fixed bin; /* number of arguments */ 51 dcl prev_ptrs (1) ptr; /* from metering_util_ */ 52 dcl 1 prev_total_wcte aligned like wct_entry; /* dummy WCTE for previous totals */ 53 dcl range_no fixed bin; /* vcpu range index */ 54 dcl report_sw bit (1); /* true if report option specified */ 55 dcl reset_sw bit (1); /* true if reset option specified */ 56 dcl tcmp1 ptr; /* pointer to previous copy of tc_data */ 57 dcl tcmp2 ptr; /* pointer to current copy of tc_data */ 58 dcl tt_arg bit (1); /* ON => -total argument given */ 59 dcl wc_alph pic "zz9"; /* work class number for printing */ 60 dcl wc_arg bit (1); /* ON => -work_class argument given */ 61 dcl wc_arg_num fixed bin; /* work class number from -work_class arg */ 62 dcl wc_num fixed bin; /* current work class number */ 63 64 /* Static */ 65 66 dcl ANSWER_TABLE char (12) int static options (constant) 67 init ("answer_table"); /* segment name of answer table */ 68 dcl CONTROL_DIR char (17) int static options (constant) 69 init (">system_control_1"); /* directory where answer_table and MGT live */ 70 dcl init_sw bit (1) int static init ("0"b); /* true if already initialized */ 71 dcl MAX_FLOAT float int static options (constant) 72 init (99.99); /* maximum floating point number we print */ 73 dcl MAX_WORK_CLASS fixed bin int static options (constant) 74 init (16); /* maximum work class allowed by system */ 75 dcl MGT char (3) int static options (constant) 76 init ("mgt"); /* segment name of the MGT */ 77 dcl mgtp ptr int static init (null ()); /* pointer to MGT */ 78 dcl MYNAME char (15) int static options (constant) 79 init ("response_meters"); 80 dcl static_ansp ptr int static init (null ()); /* pointer to answer table */ 81 dcl unique fixed bin int static init (0); /* instance number for metering_util_ */ 82 83 84 /* Based */ 85 86 dcl arg char (arg_len) based (arg_ptr); /* current argument */ 87 88 89 90 /* External */ 91 92 dcl error_table_$bad_arg fixed bin (35) external; 93 dcl error_table_$badopt fixed bin (35) external; 94 dcl error_table_$inconsistent fixed bin (35) external; 95 96 /* Entry */ 97 98 dcl com_err_ entry options (variable); 99 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 100 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 101 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); 102 dcl ioa_ entry options (variable); 103 dcl metering_util_$define_regions entry options (variable); 104 dcl metering_util_$fill_buffers entry (fixed bin, fixed bin (71), char (*), (*) ptr, (*) ptr, fixed bin (35)); 105 dcl metering_util_$reset entry (fixed bin, fixed bin (35)); 106 107 /* Condition */ 108 109 dcl conversion condition; 110 111 /* Builtin */ 112 113 dcl addr builtin; 114 dcl fixed builtin; 115 dcl min builtin; 116 dcl null builtin; 117 dcl rtrim builtin; 118 119 120 121 /* Pick up and validate arguments. If none "-report" assumed. */ 122 123 report_sw, 124 reset_sw, 125 tt_arg, 126 wc_arg = "0"b; 127 128 call cu_$arg_count (n_args, code); 129 if code ^= 0 then do; 130 call com_err_ (code, MYNAME); 131 return; 132 end; 133 134 if n_args = 0 135 then report_sw = "1"b; 136 else do arg_no = 1 to n_args; 137 call cu_$arg_ptr (arg_no, arg_ptr, arg_len, code); 138 if arg = "-report" then report_sw = "1"b; 139 else if arg = "-reset" | arg = "-rs" then reset_sw = "1"b; 140 else if arg = "-report_reset" | arg = "-rr" then do; 141 report_sw = "1"b; 142 reset_sw = "1"b; 143 end; 144 else if arg = "-work_class" | arg = "-wc" then do; 145 wc_arg = "1"b; 146 arg_no = arg_no + 1; 147 call cu_$arg_ptr (arg_no, arg_ptr, arg_len, code); 148 if code ^= 0 then do; 149 call com_err_ (code, MYNAME, "Work Class Number"); 150 return; 151 end; 152 on conversion goto invalid_work_class; 153 wc_arg_num = fixed (arg); 154 revert conversion; 155 if wc_arg_num < 0 | wc_arg_num > MAX_WORK_CLASS then do; 156 invalid_work_class: call com_err_ (error_table_$bad_arg, MYNAME, arg); 157 return; 158 end; 159 end; 160 else if arg = "-total" | arg = "-tt" | arg = "-totals" 161 then tt_arg = "1"b; 162 else do; 163 call com_err_ (error_table_$badopt, MYNAME, arg); 164 return; 165 end; 166 end; 167 168 if ^reset_sw then report_sw = "1"b; 169 if wc_arg & tt_arg then do; 170 call com_err_ (error_table_$inconsistent, MYNAME, "-work_class and -total"); 171 return; 172 end; 173 if ^report_sw & (tt_arg | wc_arg) then do; 174 call com_err_ (error_table_$inconsistent, MYNAME, "Report options without -report"); 175 return; 176 end; 177 178 179 180 181 /* Initialize if not done already */ 182 183 if ^init_sw then do; 184 call metering_util_$define_regions (unique, code, 185 "tc_data", 0, "apt"); 186 if code ^= 0 then do; 187 call com_err_ (code, MYNAME, "Defining regions."); 188 return; 189 end; 190 init_sw = "1"b; 191 end; 192 call metering_util_$fill_buffers (unique, meter_time, 193 formatted_meter_time, cur_ptrs, prev_ptrs, code); 194 if code ^= 0 then do; 195 call com_err_ (code, MYNAME, "Filling buffers."); 196 return; 197 end; 198 199 call ioa_ ("^/Total metering time^-^a^/", formatted_meter_time); 200 201 202 203 /* Print the report if requested */ 204 205 if report_sw then do; 206 207 tcmp1 = prev_ptrs (1); /* prev copy of tc_data */ 208 tcmp2 = cur_ptrs (1); /* current copy of tc_data */ 209 210 211 prev_total_wcte.number_thinks, 212 prev_total_wcte.number_queues, 213 prev_total_wcte.total_think_time, 214 prev_total_wcte.total_queue_time = 0; 215 cur_total_wcte.number_thinks, 216 cur_total_wcte.number_queues, 217 cur_total_wcte.total_think_time, 218 cur_total_wcte.total_queue_time = 0; 219 do range_no = 1 to VCPU_RESPONSE_BOUNDS + 1; 220 prev_total_wcte.number_processing (range_no), 221 prev_total_wcte.total_processing_time (range_no), 222 prev_total_wcte.total_vcpu_time (range_no) = 0; 223 cur_total_wcte.number_processing (range_no), 224 cur_total_wcte.total_processing_time (range_no), 225 cur_total_wcte.total_vcpu_time (range_no) = 0; 226 end; 227 228 229 call fill_lcg; /* pick up Load Control Group IDs */ 230 call ioa_ ("WC ---Thinks/-- ----Response Times by VCPU Range---- Load Control Group"); 231 call ioa_ ("^4x---Queues--- -VCPU Range- # Avg Avg Resp"); 232 call ioa_ ("^9x# Avg From To Int VCPU RT Fact"); 233 234 /* Print report type specified by arguments */ 235 236 if wc_arg then do; /* report on specified work class */ 237 wc_alph = wc_arg_num; 238 call stats_for_work_class (addr (tcmp2 -> tcm.wcte (wc_arg_num)), 239 addr (tcmp1 -> tcm.wcte (wc_arg_num)), (wc_alph), lcg (wc_arg_num)); 240 end; 241 else do; /* all work classes or totals */ 242 243 do wc_num = 0 to MAX_WORK_CLASS; 244 245 if tcmp2 -> tcm.wcte (wc_num).defined then do; 246 wc_alph = wc_num; 247 if ^tt_arg then 248 call stats_for_work_class (addr (tcmp2 -> tcm.wcte (wc_num)), 249 addr (tcmp1 -> tcm.wcte (wc_num)), (wc_alph), lcg (wc_num)); 250 251 cur_total_wcte.number_thinks 252 = cur_total_wcte.number_thinks + tcmp2 -> tcm.wcte (wc_num).number_thinks; 253 cur_total_wcte.number_queues 254 = cur_total_wcte.number_queues + tcmp2 -> tcm.wcte (wc_num).number_queues; 255 cur_total_wcte.total_think_time 256 = cur_total_wcte.total_think_time + tcmp2 -> tcm.wcte (wc_num).total_think_time; 257 cur_total_wcte.total_queue_time 258 = cur_total_wcte.total_queue_time + tcmp2 -> tcm.wcte (wc_num).total_queue_time; 259 do range_no = 1 to VCPU_RESPONSE_BOUNDS + 1; 260 cur_total_wcte.number_processing (range_no) 261 = cur_total_wcte.number_processing (range_no) 262 + tcmp2 -> tcm.wcte (wc_num).number_processing (range_no); 263 cur_total_wcte.total_processing_time (range_no) 264 = cur_total_wcte.total_processing_time (range_no) 265 + tcmp2 -> tcm.wcte (wc_num).total_processing_time (range_no); 266 cur_total_wcte.total_vcpu_time (range_no) 267 = cur_total_wcte.total_vcpu_time (range_no) 268 + tcmp2 -> tcm.wcte (wc_num).total_vcpu_time (range_no); 269 end; 270 271 prev_total_wcte.number_thinks 272 = prev_total_wcte.number_thinks + tcmp1 -> tcm.wcte (wc_num).number_thinks; 273 prev_total_wcte.number_queues 274 = prev_total_wcte.number_queues + tcmp1 -> tcm.wcte (wc_num).number_queues; 275 prev_total_wcte.total_think_time 276 = prev_total_wcte.total_think_time + tcmp1 -> tcm.wcte (wc_num).total_think_time; 277 prev_total_wcte.total_queue_time 278 = prev_total_wcte.total_queue_time + tcmp1 -> tcm.wcte (wc_num).total_queue_time; 279 do range_no = 1 to VCPU_RESPONSE_BOUNDS + 1; 280 prev_total_wcte.number_processing (range_no) 281 = prev_total_wcte.number_processing (range_no) 282 + tcmp1 -> tcm.wcte (wc_num).number_processing (range_no); 283 prev_total_wcte.total_processing_time (range_no) 284 = prev_total_wcte.total_processing_time (range_no) 285 + tcmp1 -> tcm.wcte (wc_num).total_processing_time (range_no); 286 prev_total_wcte.total_vcpu_time (range_no) 287 = prev_total_wcte.total_vcpu_time (range_no) 288 + tcmp1 -> tcm.wcte (wc_num).total_vcpu_time (range_no); 289 end; 290 291 292 end; 293 end; 294 call stats_for_work_class (addr (cur_total_wcte), addr (prev_total_wcte), 295 "All", ""); 296 end; 297 298 299 meter_calls = tcmp2 -> tcm.meter_response_time_calls 300 - tcmp1 -> tcm.meter_response_time_calls; 301 meter_invalid = tcmp2 -> tcm.meter_response_time_invalid 302 - tcmp1 -> tcm.meter_response_time_invalid; 303 meter_ovhd = (tcmp2 -> tcm.meter_response_time_overhead 304 - tcmp1 -> tcm.meter_response_time_overhead); 305 if meter_calls = 0 then do; 306 meter_ovhd_call = 0.0; 307 meter_ovhd = 0.0; 308 end; 309 else do; 310 meter_ovhd_call = meter_ovhd * 1.0e-3 / meter_calls; 311 meter_ovhd = meter_ovhd * 1.0e2 / (tcmp2 -> tcm.processor_time - tcmp1 -> tcm.processor_time); 312 end; 313 call ioa_ ("^/^10d calls to meter_response_time ^10d invalid transitions.^/^11xOverhead = ^6.2f% (^7.3f ms./call)^/", 314 meter_calls, meter_invalid, meter_ovhd, meter_ovhd_call); 315 316 end; 317 318 319 /* Reset if requested */ 320 321 if reset_sw then do; 322 call metering_util_$reset (unique, code); 323 if code ^= 0 then do; 324 call com_err_ (code, MYNAME, "Resetting."); 325 return; 326 end; 327 end; 328 329 return; 330 331 332 /* Internal Procedure to fill the array "lgc" with Load Control Group 333* IDs corresponding to Work Classes */ 334 335 fill_lcg: proc; 336 337 dcl curshift fixed bin; 338 dcl mgt_ix fixed bin; 339 340 341 lcg (*) = ""; 342 lcg (0) = "Init"; 343 344 if mgtp = null () then do; 345 call hcs_$initiate (CONTROL_DIR, MGT, "", 0, 1, mgtp, code); 346 if mgtp = null () then return; 347 end; 348 349 if static_ansp = null () then do; 350 call hcs_$initiate (CONTROL_DIR, ANSWER_TABLE, "", 0, 1, static_ansp, code); 351 if static_ansp = null () then return; 352 end; 353 ansp = static_ansp; 354 355 curshift = anstbl.shift; 356 357 do mgt_ix = MAX_WORK_CLASS + 1 to mgt.current_size; 358 mgtep = addr (mgt.entry (mgt_ix)); 359 lcg (group.int_wc (curshift)) = 360 lcg (group.int_wc (curshift)) || 361 rtrim (group.group_id) || " "; 362 end; 363 364 end fill_lcg; 365 366 /* Internal Procedure to compute statistics for one work class and 367* print these statistics */ 368 369 stats_for_work_class: 370 proc (cur_wcp, prev_wcp, wc_number_alph, lcg_info); 371 372 /* Parameter */ 373 374 dcl cur_wcp ptr; /* pointer to current copy of WCTE */ 375 dcl prev_wcp ptr; /* pointer to previous copy of WCTE */ 376 dcl wc_number_alph char (*); /* printable work class number */ 377 dcl lcg_info char (*) varying; /* Load Control Group information */ 378 379 /* Automatic */ 380 381 dcl avg_queue_rt float; /* average (pro-rated) queue time / interaction */ 382 dcl avg_queue float; /* average queue time */ 383 dcl avg_think float; /* average think time */ 384 dcl line_no fixed bin; /* current output line no w/i WC */ 385 dcl n_queue fixed bin; /* number of queues */ 386 dcl n_resp fixed bin; /* number of interactions */ 387 dcl n_resp_wc fixed bin; /* number of interactions for current work class */ 388 dcl n_think fixed bin; /* number of thinks */ 389 dcl range_from float; /* begin of range in sec */ 390 dcl range_to float; /* end of range in sec */ 391 dcl total_rt float; /* sum of processing times */ 392 dcl total_rt_wc float; /* sum of processing times for work class */ 393 dcl total_vcpu float; /* sum of VCPU times */ 394 dcl total_vcpu_wc float; /* sum of VCPU times for work class */ 395 396 397 398 399 400 401 n_resp_wc = 0; 402 do range_no = 1 to VCPU_RESPONSE_BOUNDS + 1; 403 n_resp_wc = n_resp_wc + cur_wcp -> wct_entry.number_processing (range_no) 404 - prev_wcp -> wct_entry.number_processing (range_no); 405 end; 406 if n_resp_wc <= 0 then return; 407 total_rt_wc, total_vcpu_wc = 0; 408 409 line_no = 1; 410 411 n_think = cur_wcp -> wct_entry.number_thinks 412 - prev_wcp -> wct_entry.number_thinks; 413 n_queue = cur_wcp -> wct_entry.number_queues 414 - prev_wcp -> wct_entry.number_queues; 415 if n_think = 0 416 then avg_think = 0.0; 417 else do; 418 avg_think = (cur_wcp -> wct_entry.total_think_time 419 - prev_wcp -> wct_entry.total_think_time) / 1.0e6; 420 avg_think = avg_think / n_think; 421 end; 422 if n_queue = 0 423 then avg_queue = 0.0; 424 else do; 425 avg_queue = (cur_wcp -> wct_entry.total_queue_time 426 - prev_wcp -> wct_entry.total_queue_time) / 1.0e6; 427 avg_queue = avg_queue / n_queue; 428 end; 429 430 avg_queue_rt = avg_queue * min (n_queue, n_resp_wc) / n_resp_wc; 431 432 if avg_think > MAX_FLOAT then avg_think = MAX_FLOAT; 433 if avg_queue > MAX_FLOAT then avg_queue = MAX_FLOAT; 434 435 /* Go through the range of virtual cpu times for the work class */ 436 437 do range_no = 1 to VCPU_RESPONSE_BOUNDS + 1; 438 if range_no = 1 439 then range_from = 0.0; 440 else range_from = tcmp2 -> tcm.vcpu_response_bounds (range_no - 1) / 1.0e6; 441 if range_no = VCPU_RESPONSE_BOUNDS + 1 442 then range_to = MAX_FLOAT; 443 else range_to = tcmp2 -> tcm.vcpu_response_bounds (range_no) / 1.0e6; 444 445 n_resp = cur_wcp -> wct_entry.number_processing (range_no) 446 - prev_wcp -> wct_entry.number_processing (range_no); 447 total_vcpu = (cur_wcp -> wct_entry.total_vcpu_time (range_no) 448 - prev_wcp -> wct_entry.total_vcpu_time (range_no)) / 1.0e6; 449 total_vcpu_wc = total_vcpu_wc + total_vcpu; 450 total_rt = (cur_wcp -> wct_entry.total_processing_time (range_no) 451 - prev_wcp -> wct_entry.total_processing_time (range_no)) / 1.0e6; 452 total_rt_wc = total_rt_wc + total_rt; 453 call print_stats (n_resp, total_rt, total_vcpu, "0"b); 454 end; 455 456 call print_stats (n_resp_wc, total_rt_wc, total_vcpu_wc, "1"b); 457 return; 458 459 460 461 /* Internal Procedure to print one line of statistics */ 462 463 print_stats: 464 proc (N_resp, T_rt, T_vcpu, total_flag); 465 466 /* Parameter */ 467 468 dcl N_resp fixed bin; /* number of interactions */ 469 dcl T_rt float; /* sum of processing time */ 470 dcl T_vcpu float; /* sum of virtual cpu time */ 471 dcl total_flag bit (1); /* ON => printing total for work class */ 472 473 /* Automatic */ 474 475 dcl avg_rt float; /* average response time */ 476 dcl avg_vcpu float; /* average virtual cpu time */ 477 dcl resp_fact float; /* response factor = avg resp time/avg vcpu time */ 478 479 if N_resp = 0 then do; 480 avg_vcpu = 0.0; 481 avg_rt = 0.0; 482 resp_fact = 0.0; 483 end; 484 else do; 485 avg_vcpu = T_vcpu / N_resp; 486 avg_rt = T_rt / N_resp + avg_queue_rt; 487 488 resp_fact = avg_rt / avg_vcpu; 489 490 if avg_vcpu > MAX_FLOAT then avg_vcpu = MAX_FLOAT; 491 if avg_rt > MAX_FLOAT then avg_rt = MAX_FLOAT; 492 if resp_fact > MAX_FLOAT then resp_fact = MAX_FLOAT; 493 end; 494 495 if N_resp > 0 then do; 496 call ioa_ ("^[^[^/^3a ^6d ^5.2f ^2s^;^3s^4x^6d ^5.2f ^]^;^6s^20x^]^[^2(----- ^)^2s^;^2(^5.2f ^)^]^6d ^3(^5.2f ^)^[ ^a^;^]", 497 (line_no <= 2), line_no, wc_number_alph, n_think, avg_think, 498 n_queue, avg_queue, total_flag, range_from, range_to, 499 N_resp, avg_vcpu, avg_rt, resp_fact, 500 (line_no = 1), lcg_info); 501 line_no = line_no + 1; 502 end; 503 504 end print_stats; 505 506 507 end stats_for_work_class; 508 509 510 /* BEGIN INCLUDE FILE ... answer_table.incl.pl1 */ 1 2 1 3 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 4 /* */ 1 5 /* The answer table has one entry per "login instance" whether completed or */ 1 6 /* not. It is connected to the Channel Definition Table by the pointer */ 1 7 /* "channel". The header is used mostly by dialup_. */ 1 8 /* */ 1 9 /* Programs which use this file must also include user_table_header.incl.pl1 */ 1 10 /* */ 1 11 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 12 1 13 /****^ HISTORY COMMENTS: 1 14* 1) change(81-09-10,Kittlitz), approve(), audit(), install(): 1 15* Replace anstbl.incl.pl1. 1 16* 2) change(85-01-15,Swenson), approve(), audit(), install(): 1 17* Add anstbl.session_uid_counter. 1 18* 3) change(85-08-21,Coren), approve(), audit(), install(): 1 19* Add anstbl.message_update_time and named constants for values of 1 20* anstbl.session, and to make all padding explicit. 1 21* 4) change(85-08-23,Coren), approve(), audit(), install(): 1 22* Change "entry" to a placeholder so as not to require 1 23* user_table_entry.incl.pl1. 1 24* 5) change(86-06-29,Swenson), approve(87-07-13,MCR7741), 1 25* audit(87-04-14,GDixon), install(87-08-04,MR12.1-1056): 1 26* Added the flag login_server_present which indicates whether a login 1 27* server request has been received. This is used to determine whether 1 28* dial_ctl_ should call uc_cleanup_network_dials_ (and thus 1 29* hpriv_connection_list_, which only exists with the MNA RPQ software). 1 30* 6) change(87-04-14,GDixon), approve(87-07-13,MCR7741), 1 31* audit(87-07-16,Brunelle), install(87-08-04,MR12.1-1056): 1 32* A) Moved constants for ute.pw_flags.mask_ctl into 1 33* user_table_entry.incl.pl1. 1 34* B) Added common table header to all user tables. 1 35* END HISTORY COMMENTS */ 1 36 1 37 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 38 /* */ 1 39 /* The anstbl structure below is divided into sections. Each section begins */ 1 40 /* with a comment describing the elements in the section. Elements are */ 1 41 /* placed within a section, based upon their function or the programs that */ 1 42 /* use them. Each section begins on a double word and is an even number of */ 1 43 /* words long. */ 1 44 /* */ 1 45 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 1 46 1 47 1 48 1 49 /* format: style4 */ 1 50 1 51 dcl ANSTBL_version_4 static options (constant) init (4); /* version of this declaration */ 1 52 1 53 dcl ansp ptr automatic init (null); 1 54 1 55 dcl 1 anstbl based (ansp) aligned, /* Structure of answer table */ 1 56 2 header like ut_header, /* Header common to all user tables. */ 1 57 1 58 /* Counter elements. */ 1 59 2 nlin fixed bin, /* number of active lines */ 1 60 2 mxlin fixed bin, /* maximum number of active lines */ 1 61 2 n_users fixed bin, /* number of logged-in users */ 1 62 2 max_users fixed bin, /* maximum number of users allowed */ 1 63 2 n_units fixed bin, /* number of logged in units */ 1 64 2 max_units fixed bin, /* maximum number of units */ 1 65 2 n_sessions fixed bin, /* number of Multics sessions */ 1 66 2 n_pad fixed bin, 1 67 1 68 /* Name elements. */ 1 69 2 sysdir char (64) unal, /* name of main system control directory */ 1 70 2 as_tty char (8) unal, /* name of main answering service device. */ 1 71 1 72 /* Login elements. */ 1 73 2 login_word char (8) unal, /* login word if special_session=1 */ 1 74 2 session char (8) unal, /* session indicator */ 1 75 2 special_message char (128) unal, /* message to be printed for special session */ 1 76 2 message_update_time fixed bin (71), /* time at which special_message was last updated */ 1 77 2 message_lng fixed bin, /* length of special message */ 1 78 2 login_pad fixed bin, 1 79 1 80 /* Table update elements. */ 1 81 2 lock_count fixed bin, /* global lock for all system control tables */ 1 82 2 update_pending bit (1) aligned, /* flag indicating that update is required */ 1 83 2 update_channel fixed binary (71), /* event channel of update procedure */ 1 84 2 acct_update_chn fixed bin (71) aligned, /* Timer IPC channel */ 1 85 2 acct_last_update_time fixed bin (71) aligned, /* Time of last accounting update */ 1 86 2 acct_alarm_fail fixed bin, /* non-zero if alarm has failed */ 1 87 2 update_pad fixed bin, 1 88 1 89 /* dialup_ data values. */ 1 90 2 current_time fixed bin (71), /* Time of last transaction */ 1 91 2 processid_index fixed bin (18), /* unique index for process id generation */ 1 92 2 session_uid_counter fixed bin (35), /* current session_uid */ 1 93 1 94 /* load_ctl_ elements. */ 1 95 2 shift fixed bin, /* Shift, set by act_ctl_ */ 1 96 2 auto_maxu fixed bin, /* 0 = manual, 1 = config, 2 = load-level */ 1 97 2 extra_units fixed bin, /* Total daemon and abs units. */ 1 98 /* load_ctl_ load leveling desired response range: */ 1 99 2 response_high fixed bin, /* bad if user response time slower than this */ 1 100 2 response_low fixed bin, /* bad if user response time faster than this */ 1 101 2 load_ctl_pad fixed bin, 1 102 1 103 /* Login server request server data. */ 1 104 2 ls_request_server_event_channel fixed bin (71), /* channel for login server requests */ 1 105 2 ls_request_server_process_id bit (36) aligned, /* process serving login server requests */ 1 106 2 login_server_present bit (1) aligned, /* On IFF a login server request has been processed */ 1 107 1 108 2 entry_pad (28) fixed bin, /* pad to 128 words */ 1 109 2 entry (0 refer (anstbl.current_size)), /* user entries */ 1 110 3 contents (UTE_SIZE) fixed bin; 1 111 1 112 /* constants */ 1 113 1 114 /* values for anstbl.session */ 1 115 1 116 dcl (AT_NORMAL init ("normal "), 1 117 AT_SPECIAL init ("special "), 1 118 AT_SHUTDOWN init ("shutdown")) char (8) internal static options (constant); 1 119 1 120 dcl UTE_SIZE fixed bin internal static initial (300); 1 121 1 122 /* END INCLUDE FILE ... answer_table.incl.pl1 */ 510 511 /* BEGIN INCLUDE FILE ... mgt.incl.pl1 */ 2 2 2 3 /* Modified May 1975 by T. Casey to add priority scheduler parameters */ 2 4 /* Modified Summer '76 RE Mullen to add deadline parameters */ 2 5 /* Modified by T. Casey, November 1978, to add group parameters: absentee_(max min pct limit). */ 2 6 /* Modified July 1981 by J. Bongiovanni to add max_pct */ 2 7 2 8 /* At login each user process is placed in that load control group specified in either 2 9* the project's SAT entry or the user's PDT entry. This group is remembered 2 10* in the user table entry for that process (ATE, DUTE, AUTE). 2 11* 2 12* MGT groups map each process into a set of processes called a work_class 2 13* as a function of shift and whether or not the process is absentee -- 2 14* also per group limits on the number of group members are given. 2 15* 2 16* The work_class entries in the MGT specify the configuration 2 17* of the hardcore scheduler on a per shift basis. If a work_class has the 2 18* realtime attribute, member processes will be given precisely specified 2 19* response characteristics. If running in deadline_not_percent mode on 2 20* a given shift then members of other work_classes will be given approximate 2 21* response characteristics; otherwise other work_classes will be given 2 22* percentages of whatever cpu time is unused by realtime processes. 2 23* REM */ 2 24 2 25 dcl MGT_version_3 fixed bin int static init (3); /* versions >= 2 contain work class definitions */ 2 26 /* versions >= 3 contain deadline info */ 2 27 2 28 /* the mgt is based on mgtp, which is declared as either static or automatic, in each procedure that uses it */ 2 29 2 30 dcl 1 mgt based (mgtp) aligned, /* the Master Group Table defines load control groups 2 31* and work classes */ 2 32 3 1 /* BEGIN INCLUDE FILE author.incl.pl1 */ 3 2 3 3 /* the "author" items must always be the first ones in the table. The 3 4* module which moves the converted table to the System Control process 3 5* fills in these data items and assumes them to be at the head of the segment 3 6* regardless of the specific table's actual declaration. The variables 3 7* "lock" and "last_install_time" used to be "process_id" and "ev_channel" 3 8* respectively. For tables installed in multiple processes, these 3 9* are to be used to lock out multiple installations. */ 3 10 3 11 /* Lock should be used as a modification lock. Since, in general, 3 12* entries may not be moved in system tables, even by installations, 3 13* it is sufficient for only installers and programs that change threads 3 14* to set or respect the lock. Simply updating data in an entry 3 15* requires no such protection. 3 16* 3 17* Last_install_time is used by readers of system tables to detect 3 18* installations or other serious modifications. By checking it before 3 19* and after copying a block of data, they can be protected against 3 20* modifications. 3 21* 3 22* Modules that set the lock should save proc_group_id, and then 3 23* put their group id there for the time they hold the lock. 3 24* if they do not actually install the, they should restore the group id. 3 25**/ 3 26 3 27 2 author aligned, /* validation data about table's author */ 3 28 3 proc_group_id char (32), /* process-group-id (personid.projectid.tag) */ 3 29 3 lock bit (36), /* installation lock */ 3 30 3 update_attributes bit (1) unal, /* update/add/delete attributes */ 3 31 3 update_authorization bit (1) unal, /* update only authorizations */ 3 32 3 deferral_notified bit (1) unal, /* installer notified of deferral of installation */ 3 33 3 pad bit (33) unaligned, 3 34 3 last_install_time fixed bin (71), 3 35 3 table char (4), /* name of table, e.g., SAT MGT TTT RTDT PDT etc. */ 3 36 3 w_dir char (64), /* author's working directory */ 3 37 3 38 /* END INCLUDE FILE author.incl.pl1 */ 2 33 2 34 /* the author structure occupies 29 words */ 2 35 2 max_size fixed bin, /* maximum size of table */ 2 36 2 current_size fixed bin, /* current number of entries */ 2 37 2 total_units fixed bin, /* total units allocated */ 2 38 2 version_indicator char (8), /* = "VERSION " for version 2 and later 2 39* (the first version of the mgt had no version number) */ 2 40 2 version fixed bin, /* version of the mgt (if version_indicator = "VERSION ") */ 2 41 2 switches aligned, 2 42 3 wc_initialized bit (1) unaligned, /* = "1"b if work classes >1 have been defined */ 2 43 3 prio_sked_enabled bit (1) unaligned, /* if this switch is turned off, the priority scheduler will not 2 44* be used by the answering service (all processes will be 2 45* put in work class 1 regardless of what the mgt says) */ 2 46 3 prio_sked_on_tape bit (1) unaligned, /* "1"b if a.s. initialization finds the priority scheduler 2 47* on the system tape */ 2 48 3 deadline_mode (0:7) bit (1) unal, /* 0 => %, 1 => deadlines (per shift) */ 2 49 3 mgt_pad1 bit (25) unaligned, /* rest of the word */ 2 50 2 user_wc_defined (16) bit (1) unaligned, /* current set of defined work classes */ 2 51 2 shift_defined (0:7) bit (1) unaligned, /* which shifts are used at this site */ 2 52 2 mgt_pad2 bit (12) unaligned, /* rest of the word */ 2 53 2 user_wc_min_pct (16) fixed bin, /* current percents for the defined work classes */ 2 54 /* the above variables occupy a total of 24 words */ 2 55 2 mgt_pad3 (11) fixed bin, /* pad the mgt header to 64 words (29 + 24 + 11) */ 2 56 2 57 2 entry (100), /* array of entries */ 2 58 3 fill (32) fixed bin; /* 32 words each */ 2 59 /* the first 16 are work classes; the rest, load control groups */ 2 60 2 61 dcl mgtep ptr; /* both types of mgt entries are based on this pointer */ 2 62 2 63 dcl 1 group based (mgtep) aligned, /* a single entry in the mgt */ 2 64 2 group_id char (8), /* group name */ 2 65 2 max_prim fixed bin, /* maximum number of primary units (-1 is special) */ 2 66 2 n_prim fixed bin, /* current number of primary units */ 2 67 2 n_sec fixed bin, /* current number of secondary units */ 2 68 2 n_eo fixed bin, /* current number of edit-only users */ 2 69 2 absolute_max fixed bin, /* Absolute maximum number of units (prime and sec) */ 2 70 2 minu fixed bin, /* Constant number of units in maxprim */ 2 71 2 num fixed bin, /* Numerator of fraction of maxunits given to maxprim */ 2 72 2 denom fixed bin, /* Denominator. Usually = normal maxunits */ 2 73 2 minamax fixed bin, /* Constant part of abs max */ 2 74 2 num1 fixed bin, /* Numerator of abs max fraction */ 2 75 2 denom1 fixed bin, /* Denominator of abs max fraction */ 2 76 2 int_wc (0:7) fixed bin (17) unaligned, /* interactive work classes, per shift */ 2 77 2 abs_wc (0:7) fixed bin (17) unaligned, /* absentee work classes, per shift */ 2 78 /* used halfwords to avoid using up all the pad - 2 79* we might need it later */ 2 80 2 absentee aligned, /* switches controlling absentee processes in this group */ 2 81 3 allowed bit (1) unaligned, /* if off, absentee users must be moved to another group */ 2 82 3 default_group bit (1) unaligned, /* if on, this is one of the groups they can be moved to */ 2 83 3 default_queue (4) bit (1) unaligned, /* if on, this is the default group for this queue */ 2 84 /* ed_mgt and up_mgt_ enforce one default group per queue */ 2 85 3 mgt_pad4 bit (30) unaligned, /* rest of the word */ 2 86 2 absentee_max fixed bin (17) unal, /* max absentees allowed from this group */ 2 87 2 absentee_min fixed bin (17) unal, /* min absentees allowed from this group */ 2 88 2 absentee_pct fixed bin (17) unal, /* this % of abs_maxu allowed to be occupied by this group */ 2 89 2 absentee_limit fixed bin (17) unal, /* result of applying above 3 parameters to current abs_maxu */ 2 90 2 n_abs fixed bin (17) unal, /* current number of background absentee users */ 2 91 2 mgt_pad5a fixed bin (17) unal, /* rest of the word */ 2 92 2 mgt_pad5 (7) fixed bin; /* pad mgt entry to 32 words */ 2 93 2 94 dcl 1 work_class based (mgtep) aligned, 2 95 2 wc_name char (8), /* overlays group.group_id, but can only be 2 96* one of the strings "1" through "16" */ 2 97 2 switches aligned, 2 98 3 defined (0:7) bit (1) unaligned, /* which shifts this work class is defined on */ 2 99 3 absentee_allowed (0:7) bit (1) unaligned, /* "1"b if absentee jobs allowed in this work class and shift */ 2 100 /* ed_mgt and up_mgt_ enforce consistency between these 2 101* and the group.absentee switches */ 2 102 3 realtime (0:7) bit (1) unaligned, /* "1"b if this work class has realtime deadlines */ 2 103 3 mgt_pad6 bit (12) unaligned, /* rest of word */ 2 104 2 min_pct (0:7) fixed bin, /* percent, on each shift */ 2 105 2 int_response (0:7) fixed bin (17) unal, /* response to interaction(.01sec) */ 2 106 2 int_quantum (0:7) fixed bin (17) unal, /* first time slice after interaction(.01sec) */ 2 107 2 response (0:7) fixed bin (17) unal, /* time between time slices(.01sec) */ 2 108 2 quantum (0:7) fixed bin (17) unal, /* second and following time slices(.01sec) */ 2 109 2 max_pct (0:7) fixed bin (17) unal, /* governed percent on each shift (0=>not governed */ 2 110 2 mgt_pad7 (1) fixed bin; /* pad mgt entry to 32 words */ 2 111 2 112 /* END INCLUDE FILE ... mgt.incl.pl1 */ 511 512 /* BEGIN INCLUDE FILE ... tcm.incl.pl1 ... used to generate tc_data cds */ 4 2 /* NOTE -- This include file has TWO counterparts in ALM: tc_meters.incl.alm and */ 4 3 /* wcte.incl.alm. They cannot be produced with cif, and must be kept up to date manually. */ 4 4 /* Modified 830914 to replace tty_polling_time with opc_polling_time... -E. A. Ranzenbach */ 4 5 /* Modified 1984.05.21 by M. Pandolf to add tc_suspend_lock */ 4 6 /* Modified 1984.11.26 by Keith Loepere for uid_array. */ 4 7 /* Modified 1984.12.06 by Keith Loepere for page create delaying. */ 4 8 4 9 dcl tcmp ptr; 4 10 4 11 dcl 1 tcm aligned based (tcmp), 4 12 2 tc_suspend_lock like lock, /* when locked, tc is suspended */ 4 13 2 cid2 fixed bin (18), 4 14 2 cid3 fixed bin (18), 4 15 2 cid4 fixed bin (18), 4 16 2 depth_count fixed bin (18), /* depth last process run */ 4 17 2 loadings fixed bin (18), /* number of process loadings */ 4 18 4 19 2 blocks fixed bin (18), /* number of calls to block */ 4 20 2 wakeups fixed bin (18), /* number of calls to wakeup */ 4 21 2 waits fixed bin (18), /* number of calls to wait */ 4 22 2 notifies fixed bin (18), /* number of calls to notify */ 4 23 2 schedulings fixed bin (18), 4 24 2 interactions fixed bin (18), /* number of interactive schedulings */ 4 25 2 avequeue fixed bin (35, 18), /* recent time average of number in queue */ 4 26 2 te_wait fixed bin (18), /* times te called from wait */ 4 27 4 28 2 te_block fixed bin (18), /* times te updated from block */ 4 29 2 te_i_stop fixed bin (18), /* times te updated from i_stop */ 4 30 2 te_pre_empt fixed bin (18), /* times te updated from pre_empt */ 4 31 2 p_interactions fixed bin, /* times interaction bit turned off because of high priority */ 4 32 2 idle fixed bin (71), /* total idle time */ 4 33 2 mp_idle fixed bin (71), /* multi-programming idle */ 4 34 4 35 2 nmp_idle fixed bin (71), /* non-multi-programming idle time */ 4 36 2 zero_idle fixed bin (71), /* zero idle time */ 4 37 2 last_time fixed bin (71), /* last time a process was run */ 4 38 2 loop_locks fixed bin (18), /* times looped on the APT lock */ 4 39 2 loop_lock_time fixed bin (18), /* time looping on the APT lock */ 4 40 2 ave_eligible fixed bin (35, 18), /* average length of eligible queue */ 4 41 2 sort_to_elhead fixed bin (18), /* 0=> no one,1 => int've only, 2 => everybody */ 4 42 2 processor_time fixed bin (71), /* total processor time on system */ 4 43 2 response_time fixed bin (71), /* estimate of response time */ 4 44 2 eligible_time fixed bin (71), /* estimate of eligible time */ 4 45 2 response_count fixed bin, /* count of response meters */ 4 46 2 eligible_count fixed bin, /* count of eligible meters */ 4 47 2 quit_counts (0:5) fixed bin, /* array of buckets indexed by state */ 4 48 2 loading_idle fixed bin (71), /* loading_idle time */ 4 49 2 delta_vcpu fixed bin (71), /* delta virtual CPU time for the system */ 4 50 2 post_purge_switch fixed bin, /* ON if post purging is to be done */ 4 51 2 time_out_severity fixed bin, /* syserr first arg for notify time outs */ 4 52 2 notify_check fixed bin, /* obsolete */ 4 53 2 quit_priority fixed bin, /* factor for scheduler quit response */ 4 54 2 iobm_polling_time fixed bin (71), /* time to poll iobm */ 4 55 2 end_of_time fixed bin (71), /* very large time */ 4 56 2 gp_at_notify fixed bin (18), /* 0 => just do get_idle_processor */ 4 57 2 gp_at_ptlnotify fixed bin (18), /* 0 => just do get_idle_processor */ 4 58 2 int_q_enabled fixed bin (18), /* 0 => no intv q in percent mode */ 4 59 2 fnp_buffer_threshold fixed bin (18), /* if fewer free buffs then stingy alloc strategy */ 4 60 /* set this to >= half n_ttylines/fnp for safety */ 4 61 4 62 /* 100 octal */ 4 63 4 64 2 depths (8) fixed bin (18), /* histogram of run depths */ 4 65 2 tdepths (8) fixed bin (71), /* histogram of times run per depth */ 4 66 2 pfdepth (8) fixed bin (18), /* histogram of page faults per depth */ 4 67 4 68 2 ptl_not_waits fixed bin (18), /* times ptl_wait noticed ptl was unlocked */ 4 69 2 gw_gp_window_count fixed bin (18), /* times window noticed */ 4 70 2 metering_lock fixed bin (18), /* 0=locked, else unlocked */ 4 71 2 ptl_waits fixed bin (18), /* num calls to ptl_wait */ 4 72 2 gp_start_count fixed bin (18), /* to detect gw_gp window lossage */ 4 73 2 gp_done_count fixed bin (18), 4 74 2 nto_check_time fixed bin (71), /* next time at which nto code will be called */ 4 75 2 nto_delta fixed bin (35), /* microsec between nto checks */ 4 76 2 nto_count fixed bin (18), /* number of times nto detected */ 4 77 2 tcpu_scheduling fixed bin (18), /* obsolete */ 4 78 2 nto_event bit (36), /* last event which NTO'd */ 4 79 2 page_notifies fixed bin (18), 4 80 2 notify_nobody_count fixed bin (18), 4 81 2 notify_nobody_event bit (36), 4 82 2 system_type fixed bin, /* used to be tcm.inter */ 4 83 4 84 2 stat (0:15) fixed bin (18), /* num apte's in each state */ 4 85 4 86 /* 200 octal */ 4 87 4 88 2 wait (8), 4 89 3 time fixed bin (18), /* histogram of page fault waiting times versus did */ 4 90 3 count fixed bin (18), 4 91 4 92 2 ready (8), 4 93 3 time fixed bin (18), /* histogram of times in ready queue */ 4 94 3 count fixed bin (18), 4 95 4 96 2 total_pf_time fixed bin (71), /* total time spent from start to end of 4 97* all page faults */ 4 98 2 total_pf_count fixed bin (18), /* total number of page faults metered */ 4 99 2 auto_tune_ws fixed bin (18), /* 0=> dont, atherwise compensate for quantum len */ 4 100 2 ocore_delta fixed bin (18), /* number of pages reserved for int users */ 4 101 2 ws_sum fixed bin (18), /* total of eligible's ws_sizes */ 4 102 2 nonidle_force_count fixed bin (18), /* count of eligibilities forced */ 4 103 2 itt_list_lock bit (36) aligned, /* Lock on ITT free list */ 4 104 2 cpu_pf_time fixed bin (71), /* total cpu time spent handling page faults */ 4 105 2 cpu_pf_count fixed bin (18), /* total count of cpu time meterings */ 4 106 2 special_offsets unaligned, 4 107 3 apt_offset bit (18), 4 108 3 pad bit (18), 4 109 2 getwork_time fixed bin (71), /* total time spent in getwork */ 4 110 2 getwork_count fixed bin (18), /* total times through getwork */ 4 111 2 short_pf_count fixed bin (18), /* number of short page faults */ 4 112 2 interrupt_time fixed bin (71), /* total time spent in interrupt */ 4 113 2 interrupt_count fixed bin (71), /* total number of metered interrupts */ 4 114 2 ocore fixed bin (35, 18), /* fraction of core for int've users */ 4 115 2 pre_empt_flag bit (36) aligned, /* controls whether preempting at done time */ 4 116 2 cumulative_memory_usage fixed binary (71), /* total number of memory usage units */ 4 117 2 processor_time_at_define_wc fixed bin (71), /* value of processor_time when WC's last defined */ 4 118 2 boost_priority fixed bin, /* number of times priority process given high priority */ 4 119 2 lost_priority fixed bin, /* number of times priority process lost eligibility */ 4 120 2 total_clock_lag fixed bin (71), /* sum of all simulated clock delays */ 4 121 2 clock_simulations fixed bin, /* number of times alarm clock interrupt was simulated */ 4 122 2 max_clock_lag fixed bin, /* largest simulated alarm clock delay */ 4 123 4 124 /* 300 octal */ 4 125 4 126 2 pdscopyl fixed bin (18), /* amount of pds to copy for new process */ 4 127 2 max_hproc_segno fixed bin, /* largest allowed hardcore segment number */ 4 128 2 prds_length fixed bin (18), /* length of PRDS */ 4 129 2 pds_length fixed bin (18), /* length of PDS */ 4 130 2 lock fixed bin (18), /* process id generator lock */ 4 131 2 id bit (36) aligned, /* next uid to be added to uid_array */ 4 132 2 system_shutdown fixed bin (18), 4 133 2 working_set_factor fixed bin (35, 18), /* working set factor */ 4 134 4 135 2 ncpu fixed bin (18), /* number of processors currently being used */ 4 136 2 last_eligible bit (18), /* last process to gain eligibility */ 4 137 2 apt_lock fixed bin (35), /* + write; 0 hidden; -1 unlocked; -(N+1) Nreaders */ 4 138 2 apt_size fixed bin (18), /* number of APT entries */ 4 139 2 realtime_q aligned like based_sentinel, /* processes with realtime deadlines */ 4 140 2 aht_size fixed bin (18), /* APT hash table size */ 4 141 2 itt_size fixed bin (18), /* number of ITT entries */ 4 142 4 143 2 dst_size fixed bin (18), /* number of allowed DST entries */ 4 144 2 itt_free_list bit (18), /* pointer to ITT free list */ 4 145 2 used_itt fixed bin (18), /* number of used ITT entries */ 4 146 2 initializer_id bit (36) aligned, /* process id of initializer */ 4 147 2 n_eligible fixed bin (18), /* number of processes eligible */ 4 148 2 max_eligible fixed bin (30), /* maximum allowed number of eligible processes */ 4 149 2 wait_enable fixed bin (18), /* turned on when waiting mechanism works */ 4 150 2 apt_entry_size fixed bin (18), /* size of an APT entry */ 4 151 4 152 2 interactive_q aligned like based_sentinel, /* head of interactive queue */ 4 153 2 dst_ptr ptr, /* pointer to device signal table */ 4 154 2 old_user ptr, /* last process to run (apt ptr ) */ 4 155 2 initialize_time fixed bin (71), /* time of initialization */ 4 156 4 157 2 init_event fixed bin (18), /* wait event during initialization */ 4 158 2 oldt fixed bin (18), /* timer reading from previous process */ 4 159 2 newt fixed bin (18), /* timer setting for new process */ 4 160 2 tefirst fixed bin (30), /* first eligible time */ 4 161 2 telast fixed bin (30), /* last eligible time */ 4 162 2 timax fixed bin (35), /* time in queue for lowest level */ 4 163 2 empty_q bit (18), /* thread of empty APT entries */ 4 164 2 working_set_addend fixed bin (18), /* additive working set parameter */ 4 165 2 ready_q_head bit (0) aligned, /* for added segdef */ 4 166 2 eligible_q_head aligned like based_sentinel, /* head of eligible queue */ 4 167 2 ready_q_tail bit (0) aligned, /* for added segdef */ 4 168 2 eligible_q_tail aligned like based_sentinel, /* tail of eligible queue */ 4 169 2 idle_tail aligned like based_sentinel, /* tail of idle list */ 4 170 2 min_eligible fixed bin (30), 4 171 2 alarm_timer_list bit (18) aligned, /* rel pointer to apt entry for next alarm timer */ 4 172 2 guaranteed_elig_inc fixed bin (35), /* amount of guaranteed eligibility time in microsecs. */ 4 173 2 priority_sched_inc fixed bin (35), /* amount of block time before process is given priority */ 4 174 2 next_alarm_time fixed bin (71), /* clock time for next alarm timer */ 4 175 2 priority_sched_time fixed bin (71), /* time for priority process to be given priority */ 4 176 2 opc_polling_time fixed bin (71), /* time to poll console DIM */ 4 177 2 disk_polling_time fixed bin (71), /* time to poll disk DIM */ 4 178 2 tape_polling_time fixed bin (71), /* time to poll tape DIM */ 4 179 2 imp_polling_time fixed bin (71), /* time to poll imp */ 4 180 2 imp_polling_lock fixed bin (18), /* do not poll if lock set */ 4 181 2 max_channels fixed bin (18), /* num special channels per process */ 4 182 4 183 /* 400 octal */ 4 184 4 185 2 system_virtual_time fixed bin (71), /* non-idle virtual time */ 4 186 2 credit_bank fixed bin (71), /* credits not yet passed out */ 4 187 2 min_wct_index bit (18) aligned, /* offset of initializer work class table entry */ 4 188 2 max_wct_index bit (18) aligned, /* offset of highest wcte currently defined */ 4 189 2 delta_vt fixed bin (71), /* temp used by pxss.compute_virtual_clocks */ 4 190 2 gross_idle_time fixed bin (71), /* idle time_used_clock */ 4 191 2 credits_per_scatter fixed bin (35), /* total number of credits awarded at once */ 4 192 2 best_credit_value fixed bin (18), /* temp for pxss.find_next_eligible */ 4 193 2 define_wc_time fixed bin (71), /* clock time when workclasses last degined */ 4 194 2 max_batch_elig fixed bin (35), 4 195 2 num_batch_elig fixed bin (35), 4 196 2 deadline_mode fixed bin (35), /* 0=> ti sorts, else deadline sorts */ 4 197 2 credits_scattered fixed bin (35), 4 198 2 max_max_eligible fixed bin (30), /* Maximum of maxe */ 4 199 2 max_stopped_stack_0 fixed bin (35), /* Maximum stack_0's suspended by stopped procs */ 4 200 2 stopped_stack_0 fixed bin (35), /* Number stack_0's suspended by stopped procs */ 4 201 2 mos_polling_interval fixed bin (35), /* for heals */ 4 202 2 mos_polling_time fixed bin (71), /* for heals */ 4 203 2 vcpu_response_bounds (VCPU_RESPONSE_BOUNDS) fixed bin (35), 4 204 2 vcpu_response_bounds_size fixed bin (35), 4 205 2 meter_response_time_calls fixed bin (35), 4 206 2 meter_response_time_invalid fixed bin (35), 4 207 2 meter_response_time_overhead fixed bin (71), 4 208 2 init_wait_time fixed bin (71), /* used by wait/notify during initialization */ 4 209 2 init_wait_timeout fixed bin (71), /* notify-timeout interval during initialization */ 4 210 2 init_timeout_severity fixed bin, /* notify-timeout severity during initialization */ 4 211 2 init_timeout_recurse fixed bin, /* count of NTO recursion during initialization */ 4 212 2 max_timer_register fixed bin (71), /* max cpu burst = # cpus x pre_empt_sample_time */ 4 213 2 pre_empt_sample_time fixed bin (35), /* tuning parameter - max time between samples */ 4 214 2 governing_credit_bank fixed bin (35), /* used for limiting eligibility on governed work classes*/ 4 215 2 process_initial_quantum fixed bin (35), /* eligibility quantum first eligibility */ 4 216 2 default_procs_required bit (8) aligned, /* default mask of CPUs required */ 4 217 2 work_class_idle fixed bin (71), /* idle time due to work class restrictions */ 4 218 4 219 /* Tuning Parameters for Stack Truncation */ 4 220 4 221 2 stk_truncate bit (1) aligned, 4 222 2 stk_truncate_always bit (1) aligned, 4 223 2 stk_trunc_avg_f1 fixed bin (35, 18), 4 224 2 stk_trunc_avg_f2 fixed bin (35, 18), 4 225 2 lock_error_severity fixed bin, /* syserr severity */ 4 226 4 227 2 gv_integration fixed bin (35), /* Integration interval for governing */ 4 228 2 gv_integration_set bit (1) aligned, /* ON => gv_integration set by ctp */ 4 229 2 pauses fixed bin (35), /* Calls to pause (reschedule) */ 4 230 2 volmap_polling_time fixed bin (71), 4 231 2 next_ring0_timer fixed bin (71), /* next time that ring 0 timer goes off */ 4 232 2 realtime_io_priority_switch fixed bin, /* 0 => give I/O interrupt wakeups realtime priotiry */ 4 233 2 realtime_io_deadline fixed bin (35), /* Delta to clock for I/O realtime deadline */ 4 234 2 realtime_io_quantum fixed bin (35), /* Quantum for I/O realtime burst */ 4 235 2 realtime_priorities fixed bin (35), /* Count for metering */ 4 236 2 relinquishes fixed bin (35), /* Calls to relinquish_priority */ 4 237 2 abort_ips_mask bit (36) aligned, /* IPS mask for tc_util$check_abort */ 4 238 4 239 /* 500 octal */ 4 240 4 241 2 uid_array (0:15) bit (36) aligned, /* array from which a uid is chosen (randomly) */ 4 242 2 pad5 (176) fixed bin (35), /* room for expansion compatibly */ 4 243 4 244 /* 1000 octal */ 4 245 4 246 2 pad7 (64) fixed bin (35), 4 247 4 248 /* 1100 octal */ 4 249 4 250 2 pad6 (8) fixed bin (35), 4 251 2 work_class_table aligned, /* array of per workclass information */ 4 252 3 wcte (0:16) aligned like wct_entry, 4 253 4 254 /* 3000 octal */ 4 255 4 256 2 apt fixed bin; 4 257 4 258 dcl wctep ptr; 4 259 4 260 dcl 1 wct_entry aligned based (wctep), /* Work class entry */ 4 261 2 thread unaligned, /* Ready list */ 4 262 3 fp bit (18), /* Head of ready list */ 4 263 3 bp bit (18), /* Tail of ready list */ 4 264 2 flags unaligned, 4 265 3 mnbz bit (1), /* Sentinel bit must not be zero. */ 4 266 3 defined bit (1), 4 267 3 io_priority bit (1), 4 268 3 governed bit (1), 4 269 3 interactive_q bit (1), 4 270 3 pad bit (31), 4 271 2 credits fixed bin (35), /* Current worthiness of group */ 4 272 2 minf fixed bin (35), /* min fraction of cpu */ 4 273 2 pin_weight fixed bin (35), /* number of cycles to pin pages */ 4 274 2 eligibilities fixed bin (35), /* Count of eligibilities awarded */ 4 275 2 cpu_sum fixed bin (71), /* CPU used by members */ 4 276 2 resp1 fixed bin (71), 4 277 2 resp2 fixed bin (71), 4 278 2 quantum1 fixed bin (35), 4 279 2 quantum2 fixed bin (35), 4 280 2 rmeter1 fixed bin (71), 4 281 2 rmeter2 fixed bin (71), 4 282 2 rcount1 fixed bin (35), 4 283 2 rcount2 fixed bin (35), 4 284 2 realtime fixed bin (35), 4 285 2 purging fixed bin (35), 4 286 2 maxel fixed bin (35), 4 287 2 nel fixed bin (35), 4 288 2 number_thinks fixed bin (35), /* number times process entered "think" state */ 4 289 2 number_queues fixed bin (35), /* number times process entered "queued" state */ 4 290 2 total_think_time fixed bin (71), 4 291 2 total_queue_time fixed bin (71), 4 292 4 293 /* The next three arrays correspond to the array vcpu_response_bounds */ 4 294 4 295 2 number_processing (VCPU_RESPONSE_BOUNDS+1) fixed bin (35), /* number times entered "processing" state */ 4 296 2 total_processing_time (VCPU_RESPONSE_BOUNDS+1) fixed bin (71), 4 297 2 total_vcpu_time (VCPU_RESPONSE_BOUNDS+1) fixed bin (71), 4 298 2 maxf fixed bin (35), /* maximum fraction of cpu time */ 4 299 2 governing_credits fixed bin (35), /* for limiting cpu resources */ 4 300 2 pad1 (4) fixed bin (35); 4 301 4 302 4 303 dcl 1 based_sentinel aligned based, /* format of pxss-style sentinel */ 4 304 2 fp bit (18) unal, 4 305 2 bp bit (18) unal, 4 306 2 sentinel bit (36) aligned; 4 307 4 308 dcl VCPU_RESPONSE_BOUNDS fixed bin init (3) int static options (constant); 4 309 4 310 /* END INCLUDE FILE tcm.incl.pl1 */ 512 513 /* Begin include file hc_lock.incl.pl1 BIM 2/82 */ 5 2 /* Replaced by hc_fast_lock.incl.pl1 RSC 11/84 because name of structure 5 3* encourages name conflicts. 5 4* USE HC_FAST_LOCK INSTEAD! 5 5**/ 5 6 5 7 /* Lock format suitable for use with lock$lock_fast, unlock_fast */ 5 8 5 9 /* format: style3 */ 5 10 5 11 declare lock_ptr pointer; 5 12 declare 1 lock aligned based (lock_ptr), 5 13 2 pid bit (36) aligned, /* holder of lock */ 5 14 2 event bit (36) aligned, /* event associated with lock */ 5 15 2 flags aligned, 5 16 3 notify_sw bit (1) unaligned, 5 17 3 pad bit (35) unaligned; /* certain locks use this pad, like dirs */ 5 18 5 19 /* End include file hc_lock.incl.pl1 */ 513 514 /* BEGIN INCLUDE FILE ... user_table_header.incl.pl1 */ 6 2 6 3 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 6 4 /* */ 6 5 /* This include file declares the header shared by the answer_table, */ 6 6 /* absentee_user_table and daemon_user_table include files. */ 6 7 /* */ 6 8 /* * * * * * * * * * * * * * * * * * * * * * * * * * */ 6 9 6 10 /****^ HISTORY COMMENTS: 6 11* 1) change(87-04-26,GDixon), approve(87-07-13,MCR7741), 6 12* audit(87-07-16,Brunelle), install(87-08-04,MR12.1-1056): 6 13* Initial coding. 6 14* END HISTORY COMMENTS */ 6 15 6 16 dcl 1 ut_header aligned based, /* header shared by all user control tables. */ 6 17 2 header_version fixed bin, /* version of the header (3) */ 6 18 2 entry_version fixed bin, /* version of user table entries */ 6 19 2 user_table_type fixed bin, /* 1 interactive, 2 absentee, 3 daemon */ 6 20 2 header_length fixed bin, /* length of the header */ 6 21 2 max_size fixed bin, /* max number of entries in this table */ 6 22 2 current_size fixed bin, /* actual size of table (in entries) */ 6 23 2 number_free fixed bin, /* number of free entries in the table. */ 6 24 2 first_free fixed bin, /* index of first entry in the free list. */ 6 25 2 as_procid bit (36), /* process ID of user table manager process */ 6 26 2 ut_header_pad fixed bin; 6 27 6 28 /* END INCLUDE FILE ... user_table_header.incl.pl1 */ 514 515 516 end response_meters; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 08/04/87 1222.5 response_meters.pl1 >special_ldd>install>MR12.1-1054>response_meters.pl1 510 1 08/04/87 1210.2 answer_table.incl.pl1 >spec>install>1056>answer_table.incl.pl1 511 2 08/10/81 1843.7 mgt.incl.pl1 >ldd>include>mgt.incl.pl1 2-33 3 04/21/82 1211.8 author.incl.pl1 >ldd>include>author.incl.pl1 512 4 01/30/85 1523.9 tcm.incl.pl1 >ldd>include>tcm.incl.pl1 513 5 01/06/85 1422.1 hc_lock.incl.pl1 >ldd>include>hc_lock.incl.pl1 514 6 08/04/87 1138.0 user_table_header.incl.pl1 >spec>install>1056>user_table_header.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. ANSWER_TABLE 000013 constant char(12) initial unaligned dcl 66 set ref 350* CONTROL_DIR 000006 constant char(17) initial unaligned dcl 68 set ref 345* 350* MAX_FLOAT 000005 constant float bin(27) initial dcl 71 ref 432 432 433 433 441 490 490 491 491 492 492 MAX_WORK_CLASS constant fixed bin(17,0) initial dcl 73 ref 44 155 243 357 MGT 000004 constant char(3) initial unaligned dcl 75 set ref 345* MYNAME 000000 constant char(15) initial unaligned dcl 78 set ref 130* 149* 156* 163* 170* 174* 187* 195* 324* N_resp parameter fixed bin(17,0) dcl 468 set ref 463 479 485 486 495 496* T_rt parameter float bin(27) dcl 469 ref 463 486 T_vcpu parameter float bin(27) dcl 470 ref 463 485 VCPU_RESPONSE_BOUNDS constant fixed bin(17,0) initial dcl 4-308 ref 42 42 42 52 52 52 219 220 220 220 223 223 223 238 238 238 238 238 238 238 238 238 238 238 238 238 238 238 238 245 245 245 245 247 247 247 247 247 247 247 247 247 247 247 247 247 247 247 247 251 251 251 251 253 253 253 253 255 255 255 255 257 257 257 257 259 260 260 260 260 263 263 263 263 263 263 263 266 266 266 266 266 266 266 266 266 266 271 271 271 271 273 273 273 273 275 275 275 275 277 277 277 277 279 280 280 280 280 283 283 283 283 283 283 283 286 286 286 286 286 286 286 286 286 286 299 299 301 301 303 303 402 437 441 447 447 447 447 450 450 addr builtin function dcl 113 ref 238 238 238 238 247 247 247 247 294 294 294 294 358 ansp 000152 automatic pointer initial dcl 1-53 set ref 1-53* 353* 355 anstbl based structure level 1 dcl 1-55 arg based char unaligned dcl 86 set ref 138 139 139 140 140 144 144 153 156* 160 160 160 163* arg_len 000100 automatic fixed bin(21,0) dcl 37 set ref 137* 138 139 139 140 140 144 144 147* 153 156 156 160 160 160 163 163 arg_no 000101 automatic fixed bin(17,0) dcl 38 set ref 136* 137* 146* 146 147* arg_ptr 000102 automatic pointer dcl 39 set ref 137* 138 139 139 140 140 144 144 147* 153 156 160 160 160 163 avg_queue 000215 automatic float bin(27) dcl 382 set ref 422* 425* 427* 427 430 433 433* 496* avg_queue_rt 000214 automatic float bin(27) dcl 381 set ref 430* 486 avg_rt 000242 automatic float bin(27) dcl 475 set ref 481* 486* 488 491 491* 496* avg_think 000216 automatic float bin(27) dcl 383 set ref 415* 418* 420* 420 432 432* 496* avg_vcpu 000243 automatic float bin(27) dcl 476 set ref 480* 485* 488 490 490* 496* based_sentinel based structure level 1 dcl 4-303 code 000104 automatic fixed bin(35,0) dcl 40 set ref 128* 129 130* 137* 147* 148 149* 184* 186 187* 192* 194 195* 322* 323 324* 345* 350* com_err_ 000026 constant entry external dcl 98 ref 130 149 156 163 170 174 187 195 324 conversion 000144 stack reference condition dcl 109 ref 152 154 cu_$arg_count 000030 constant entry external dcl 99 ref 128 cu_$arg_ptr 000032 constant entry external dcl 100 ref 137 147 cur_ptrs 000106 automatic pointer array dcl 41 set ref 192* 208 cur_total_wcte 000110 automatic structure level 1 dcl 42 set ref 294 294 cur_wcp parameter pointer dcl 374 ref 369 403 411 413 418 425 445 447 450 current_size 36 based fixed bin(17,0) level 2 dcl 2-30 ref 357 curshift 000202 automatic fixed bin(17,0) dcl 337 set ref 355* 359 359 defined based bit(1) array level 5 packed unaligned dcl 4-11 set ref 245 entry 100 based structure array level 2 dcl 2-30 set ref 358 error_table_$bad_arg 000020 external static fixed bin(35,0) dcl 92 set ref 156* error_table_$badopt 000022 external static fixed bin(35,0) dcl 93 set ref 163* error_table_$inconsistent 000024 external static fixed bin(35,0) dcl 94 set ref 170* 174* fixed builtin function dcl 114 ref 153 flags based structure array level 4 packed unaligned dcl 4-11 formatted_meter_time 000110 automatic char(10) unaligned dcl 43 set ref 192* 199* group based structure level 1 dcl 2-63 group_id based char(8) level 2 dcl 2-63 ref 359 hcs_$initiate 000034 constant entry external dcl 101 ref 345 350 init_sw 000010 internal static bit(1) initial unaligned dcl 70 set ref 183 190* int_wc 15 based fixed bin(17,0) array level 2 packed unaligned dcl 2-63 ref 359 359 ioa_ 000036 constant entry external dcl 102 ref 199 230 231 232 313 496 lcg 000113 automatic varying char(32) array dcl 44 set ref 238* 247* 341* 342* 359* 359 lcg_info parameter varying char dcl 377 set ref 369 496* line_no 000217 automatic fixed bin(17,0) dcl 384 set ref 409* 496 496* 496 501* 501 lock based structure level 1 dcl 5-12 meter_calls 000113 automatic fixed bin(17,0) dcl 45 set ref 299* 305 310 313* meter_invalid 000114 automatic fixed bin(17,0) dcl 46 set ref 301* 313* meter_ovhd 000115 automatic float bin(27) dcl 47 set ref 303* 307* 310 311* 311 313* meter_ovhd_call 000116 automatic float bin(27) dcl 48 set ref 306* 310* 313* meter_response_time_calls based fixed bin(35,0) level 2 dcl 4-11 ref 299 299 meter_response_time_invalid based fixed bin(35,0) level 2 dcl 4-11 ref 301 301 meter_response_time_overhead based fixed bin(71,0) level 2 dcl 4-11 ref 303 303 meter_time 000120 automatic fixed bin(71,0) dcl 49 set ref 192* metering_util_$define_regions 000040 constant entry external dcl 103 ref 184 metering_util_$fill_buffers 000042 constant entry external dcl 104 ref 192 metering_util_$reset 000044 constant entry external dcl 105 ref 322 mgt based structure level 1 dcl 2-30 mgt_ix 000203 automatic fixed bin(17,0) dcl 338 set ref 357* 358* mgtep 000154 automatic pointer dcl 2-61 set ref 358* 359 359 359 mgtp 000012 internal static pointer initial dcl 77 set ref 344 345* 346 357 358 min builtin function dcl 115 ref 430 n_args 000122 automatic fixed bin(17,0) dcl 50 set ref 128* 134 136 n_queue 000220 automatic fixed bin(17,0) dcl 385 set ref 413* 422 427 430 496* n_resp 000221 automatic fixed bin(17,0) dcl 386 set ref 445* 453* n_resp_wc 000222 automatic fixed bin(17,0) dcl 387 set ref 401* 403* 403 406 430 430 456* n_think 000223 automatic fixed bin(17,0) dcl 388 set ref 411* 415 420 496* null builtin function dcl 116 ref 1-53 344 346 349 351 number_processing 36 000126 automatic fixed bin(35,0) array level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 220* 280* 280 number_processing based fixed bin(35,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 260 280 number_processing 36 based fixed bin(35,0) array level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 403 403 445 445 number_processing 36 000110 automatic fixed bin(35,0) array level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 223* 260* 260 number_queues 31 000126 automatic fixed bin(35,0) level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 211* 273* 273 number_queues 31 based fixed bin(35,0) level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 413 413 number_queues based fixed bin(35,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 253 273 number_queues 31 000110 automatic fixed bin(35,0) level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 215* 253* 253 number_thinks 30 000110 automatic fixed bin(35,0) level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 215* 251* 251 number_thinks based fixed bin(35,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 251 271 number_thinks 30 000126 automatic fixed bin(35,0) level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 211* 271* 271 number_thinks 30 based fixed bin(35,0) level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 411 411 prev_ptrs 000124 automatic pointer array dcl 51 set ref 192* 207 prev_total_wcte 000126 automatic structure level 1 dcl 52 set ref 294 294 prev_wcp parameter pointer dcl 375 ref 369 403 411 413 418 425 445 447 450 processor_time 42 based fixed bin(71,0) level 2 dcl 4-11 ref 311 311 range_from 000224 automatic float bin(27) dcl 389 set ref 438* 440* 496* range_no 000126 automatic fixed bin(17,0) dcl 53 set ref 219* 220 220 220 223 223 223* 259* 260 260 260 263 263 263 266 266 266* 279* 280 280 280 283 283 283 286 286 286* 402* 403 403* 437* 438 440 441 443 445 445 447 447 450 450* range_to 000225 automatic float bin(27) dcl 390 set ref 441* 443* 496* report_sw 000127 automatic bit(1) unaligned dcl 54 set ref 123* 134* 138* 141* 168* 173 205 reset_sw 000130 automatic bit(1) unaligned dcl 55 set ref 123* 139* 142* 168 321 resp_fact 000244 automatic float bin(27) dcl 477 set ref 482* 488* 492 492* 496* rtrim builtin function dcl 117 ref 359 shift 132 based fixed bin(17,0) level 2 dcl 1-55 ref 355 static_ansp 000014 internal static pointer initial dcl 80 set ref 349 350* 351 353 tcm based structure level 1 dcl 4-11 tcmp1 000132 automatic pointer dcl 56 set ref 207* 238 238 247 247 271 273 275 277 280 283 286 299 301 303 311 tcmp2 000134 automatic pointer dcl 57 set ref 208* 238 238 245 247 247 251 253 255 257 260 263 266 299 301 303 311 440 443 total_flag parameter bit(1) unaligned dcl 471 set ref 463 496* total_processing_time based fixed bin(71,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 263 283 total_processing_time 000110 automatic fixed bin(71,0) array level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 223* 263* 263 total_processing_time 000126 automatic fixed bin(71,0) array level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 220* 283* 283 total_processing_time based fixed bin(71,0) array level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 450 450 total_queue_time 34 000110 automatic fixed bin(71,0) level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 215* 257* 257 total_queue_time 34 based fixed bin(71,0) level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 425 425 total_queue_time based fixed bin(71,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 257 277 total_queue_time 34 000126 automatic fixed bin(71,0) level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 211* 277* 277 total_rt 000226 automatic float bin(27) dcl 391 set ref 450* 452 453* total_rt_wc 000227 automatic float bin(27) dcl 392 set ref 407* 452* 452 456* total_think_time 32 000110 automatic fixed bin(71,0) level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 215* 255* 255 total_think_time 32 based fixed bin(71,0) level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 418 418 total_think_time based fixed bin(71,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 255 275 total_think_time 32 000126 automatic fixed bin(71,0) level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 211* 275* 275 total_vcpu 000230 automatic float bin(27) dcl 393 set ref 447* 449 453* total_vcpu_time based fixed bin(71,0) array level 4 in structure "tcm" dcl 4-11 in procedure "response_meters" set ref 266 286 total_vcpu_time 000110 automatic fixed bin(71,0) array level 2 in structure "cur_total_wcte" dcl 42 in procedure "response_meters" set ref 223* 266* 266 total_vcpu_time 000126 automatic fixed bin(71,0) array level 2 in structure "prev_total_wcte" dcl 52 in procedure "response_meters" set ref 220* 286* 286 total_vcpu_time based fixed bin(71,0) array level 2 in structure "wct_entry" dcl 4-260 in procedure "response_meters" ref 447 447 total_vcpu_wc 000231 automatic float bin(27) dcl 394 set ref 407* 449* 449 456* tt_arg 000136 automatic bit(1) unaligned dcl 58 set ref 123* 160* 169 173 247 unique 000016 internal static fixed bin(17,0) initial dcl 81 set ref 184* 192* 322* ut_header based structure level 1 dcl 6-16 vcpu_response_bounds 430 based fixed bin(35,0) array level 2 dcl 4-11 ref 440 443 wc_alph 000137 automatic picture(3) unaligned dcl 59 set ref 237* 238 246* 247 wc_arg 000140 automatic bit(1) unaligned dcl 60 set ref 123* 145* 169 173 236 wc_arg_num 000141 automatic fixed bin(17,0) dcl 61 set ref 153* 155 155 237 238 238 238 238 238 wc_num 000142 automatic fixed bin(17,0) dcl 62 set ref 243* 245 246 247 247 247 247 247 251 253 255 257 260 263 266 271 273 275 277 280 283 286* wc_number_alph parameter char unaligned dcl 376 set ref 369 496* wct_entry based structure level 1 dcl 4-260 wcte based structure array level 3 dcl 4-11 set ref 238 238 238 238 247 247 247 247 work_class_table based structure level 2 dcl 4-11 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ANSTBL_version_4 internal static fixed bin(17,0) initial dcl 1-51 AT_NORMAL internal static char(8) initial unaligned dcl 1-116 AT_SHUTDOWN internal static char(8) initial unaligned dcl 1-116 AT_SPECIAL internal static char(8) initial unaligned dcl 1-116 MGT_version_3 internal static fixed bin(17,0) initial dcl 2-25 UTE_SIZE internal static fixed bin(17,0) initial dcl 1-120 lock_ptr automatic pointer dcl 5-11 tcmp automatic pointer dcl 4-9 wctep automatic pointer dcl 4-258 work_class based structure level 1 dcl 2-94 NAMES DECLARED BY EXPLICIT CONTEXT. fill_lcg 002445 constant entry internal dcl 335 ref 229 invalid_work_class 000651 constant label dcl 156 ref 152 print_stats 003260 constant entry internal dcl 463 ref 453 456 response_meters 000342 constant entry external dcl 13 stats_for_work_class 002734 constant entry internal dcl 369 ref 238 247 294 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3662 3730 3512 3672 Length 4252 3512 46 306 147 10 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME response_meters 542 external procedure is an external procedure. on unit on line 152 64 on unit fill_lcg internal procedure shares stack frame of external procedure response_meters. stats_for_work_class internal procedure shares stack frame of external procedure response_meters. print_stats internal procedure shares stack frame of external procedure response_meters. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 init_sw response_meters 000012 mgtp response_meters 000014 static_ansp response_meters 000016 unique response_meters STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME response_meters 000100 arg_len response_meters 000101 arg_no response_meters 000102 arg_ptr response_meters 000104 code response_meters 000106 cur_ptrs response_meters 000110 cur_total_wcte response_meters 000110 formatted_meter_time response_meters 000113 lcg response_meters 000113 meter_calls response_meters 000114 meter_invalid response_meters 000115 meter_ovhd response_meters 000116 meter_ovhd_call response_meters 000120 meter_time response_meters 000122 n_args response_meters 000124 prev_ptrs response_meters 000126 range_no response_meters 000126 prev_total_wcte response_meters 000127 report_sw response_meters 000130 reset_sw response_meters 000132 tcmp1 response_meters 000134 tcmp2 response_meters 000136 tt_arg response_meters 000137 wc_alph response_meters 000140 wc_arg response_meters 000141 wc_arg_num response_meters 000142 wc_num response_meters 000152 ansp response_meters 000154 mgtep response_meters 000202 curshift fill_lcg 000203 mgt_ix fill_lcg 000214 avg_queue_rt stats_for_work_class 000215 avg_queue stats_for_work_class 000216 avg_think stats_for_work_class 000217 line_no stats_for_work_class 000220 n_queue stats_for_work_class 000221 n_resp stats_for_work_class 000222 n_resp_wc stats_for_work_class 000223 n_think stats_for_work_class 000224 range_from stats_for_work_class 000225 range_to stats_for_work_class 000226 total_rt stats_for_work_class 000227 total_rt_wc stats_for_work_class 000230 total_vcpu stats_for_work_class 000231 total_vcpu_wc stats_for_work_class 000242 avg_rt print_stats 000243 avg_vcpu print_stats 000244 resp_fact print_stats THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 r_e_as r_le_a alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out return_mac tra_ext_1 alloc_auto_adj enable_op shorten_stack ext_entry int_entry any_to_any_truncate_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr hcs_$initiate ioa_ metering_util_$define_regions metering_util_$fill_buffers metering_util_$reset THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$bad_arg error_table_$badopt error_table_$inconsistent LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 13 000341 42 000347 44 000365 52 000374 1 53 000377 238 000401 123 000403 128 000407 129 000417 130 000421 131 000436 134 000437 136 000444 137 000453 138 000470 139 000501 140 000514 141 000524 142 000526 143 000527 144 000530 145 000540 146 000542 147 000543 148 000560 149 000562 150 000611 152 000612 153 000631 154 000644 155 000645 156 000651 157 000675 159 000676 160 000677 163 000716 164 000742 166 000743 168 000745 169 000751 170 000755 171 001001 173 001002 174 001010 175 001034 183 001035 184 001040 186 001075 187 001077 188 001123 190 001124 192 001127 194 001162 195 001164 196 001213 199 001214 205 001234 207 001236 208 001240 211 001242 215 001250 219 001255 220 001265 223 001307 226 001314 229 001316 230 001317 231 001333 232 001347 236 001363 237 001365 238 001375 240 001470 243 001471 245 001477 246 001551 247 001561 251 001622 253 001671 255 001701 257 001710 259 001717 260 001727 263 002003 266 002022 269 002036 271 002040 273 002107 275 002117 277 002126 279 002135 280 002145 283 002221 286 002240 289 002254 293 002256 294 002260 299 002272 301 002303 303 002311 305 002322 306 002324 307 002326 308 002327 310 002330 311 002336 313 002347 321 002401 322 002403 323 002414 324 002416 325 002443 329 002444 335 002445 341 002446 342 002464 344 002470 345 002475 346 002540 349 002546 350 002552 351 002615 353 002623 355 002625 357 002630 358 002641 359 002646 362 002730 364 002733 369 002734 401 002752 402 002753 403 002763 405 003000 406 003002 407 003005 409 003010 411 003012 413 003025 415 003033 418 003040 420 003050 422 003054 425 003061 427 003071 430 003075 432 003110 433 003115 437 003122 438 003131 440 003136 441 003146 443 003155 445 003165 447 003201 449 003226 450 003230 452 003243 453 003245 454 003251 456 003253 457 003257 463 003260 479 003262 480 003264 481 003266 482 003267 483 003270 485 003271 486 003275 488 003301 490 003303 491 003310 492 003315 495 003322 496 003324 501 003440 504 003441 ----------------------------------------------------------- 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