COMPILATION LISTING OF SEGMENT display_fnp_idle Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/15/82 1604.3 mst Mon 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 10 11 /* format: style4,delnl,insnl,^ifthendo */ 12 display_fnp_idle: 13 procedure; 14 15 /* This command displays the data accumulated in segments by meter_fnp_idle. The 16* information is displayed either in summary form or as a histogram over a specified 17* time interval. */ 18 19 /* Written January 1982 by Robert S. Coren */ 20 /* Modified March 1981 by Robert S. Coren to fix entry-counting bugs */ 21 22 23 /* AUTOMATIC */ 24 25 dcl dirname char (168); 26 dcl hist bit (1); 27 dcl summary bit (1); 28 dcl from_time fixed bin (71); 29 dcl to_time fixed bin (71); 30 dcl minutes fixed bin; 31 dcl line_length fixed bin; 32 dcl code fixed bin (35); 33 dcl fnp_names (8) char (1); 34 dcl fnps (8) bit (1); /* indicates whether an FNP is to be included */ 35 dcl fnpx fixed bin; 36 dcl nargs fixed bin; 37 dcl iarg fixed bin; 38 dcl fnp_no fixed bin; 39 dcl areap pointer; 40 dcl earliest_of_all fixed bin (71); 41 dcl latest_of_all fixed bin (71); 42 dcl fnp_name char (1); 43 dcl i fixed bin; 44 dcl ok bit (1); 45 dcl starname char (32); 46 dcl entryx fixed bin; 47 dcl earliest_found bit (1); 48 dcl latest_found bit (1); 49 dcl segx fixed bin; 50 dcl entname char (32); 51 dcl last_segx fixed bin; 52 dcl last_start fixed bin (71); 53 dcl last_finish fixed bin (71); 54 dcl last_entry fixed bin; 55 dcl last_time_in_seg fixed bin (71); 56 dcl last_entry_in_seg fixed bin; 57 dcl opening_time fixed bin (71); 58 dcl closing_time fixed bin (71); 59 dcl time_to_stop fixed bin (71); 60 dcl total_entries fixed bin; 61 dcl beginning_found bit (1); 62 dcl prev_fnp_idle_datap pointer; 63 dcl first_segx fixed bin; 64 dcl first_entry fixed bin; 65 dcl first_idle_count fixed bin (35); 66 dcl first_sample_count fixed bin (35); 67 dcl last_idle_count fixed bin (35); 68 dcl last_sample_count fixed bin (35); 69 dcl latest_beginning fixed bin (71); 70 dcl min_sample fixed bin (35); 71 dcl minimum_time fixed bin (71); 72 dcl start_of_minimum_average fixed bin (71); 73 dcl min_idle fixed bin (35); 74 dcl min_idle_time fixed bin (71); 75 dcl total_samples fixed bin (35); 76 dcl absolute_max fixed bin (35); 77 dcl overall_average float bin; 78 dcl start_time_string char (24); 79 dcl end_time_string char (24); 80 dcl start_string char (16); 81 dcl end_string char (16); 82 dcl average_sample fixed bin (35); 83 dcl minimum_average float bin; 84 dcl min_start_string char (24); 85 dcl min_end_string char (24); 86 dcl min_idle_string char (24); 87 dcl hist_interval fixed bin (71); 88 dcl total_intervals fixed bin; 89 dcl no_of_fnps fixed bin; 90 dcl minimum_idle fixed bin; 91 dcl fnp_id fixed bin; 92 dcl next_time fixed bin (71); 93 dcl valuex fixed bin; 94 dcl residual bit (1); 95 dcl entries_per_interval fixed bin; 96 dcl last_interval_start fixed bin; 97 dcl max_idle fixed bin (35); 98 dcl next_entryx fixed bin; 99 dcl latest_time fixed bin (71); 100 dcl last_origin pointer; 101 dcl end_of_last pointer; 102 dcl last_interval fixed bin (71); 103 dcl remaining_entries fixed bin; 104 dcl scale_marks fixed bin; 105 dcl top_of_scale fixed bin; 106 dcl hist_width fixed bin; 107 dcl cols_per_pct float bin; 108 dcl space fixed bin; 109 dcl ioa_str char (32); 110 dcl ioa_strl fixed bin; 111 dcl any bit (1); 112 dcl prev_date char (8); 113 dcl cur_time fixed bin (71); 114 dcl suppressed (8) fixed bin; 115 dcl line fixed bin; 116 dcl cells fixed bin; 117 dcl last_had_data bit (1); 118 dcl output_line char (120); 119 dcl dt_string char (24); 120 dcl cur_column fixed bin; 121 dcl already fixed bin; 122 dcl new fixed bin; 123 124 dcl 1 output (8) aligned, 125 2 column fixed bin, 126 2 name char (1); 127 128 dcl 1 fnp_info_array (8) aligned like fnp_histogram_info; 129 130 dcl names_array_ptr pointer; 131 dcl seg_array_ptr pointer; 132 dcl seg_count fixed bin; 133 dcl idle_value_ptr pointer; 134 dcl infop pointer; 135 136 137 /* ARGUMENT PARSING */ 138 139 dcl argp pointer; 140 dcl argl fixed bin (21); 141 dcl arg char (argl) based (argp); 142 143 144 /* BASED */ 145 146 dcl the_area area (261120) based (areap); 147 148 dcl 1 auto_area_info aligned like area_info; 149 150 dcl 1 names_array aligned based (names_array_ptr), /* used in call to sort_intems_ */ 151 2 n_names, 152 2 name_ptr (star_entry_count refer (names_array.n_names)) pointer unaligned; 153 154 dcl 1 seg_array aligned based (seg_array_ptr), 155 2 no_of_segs fixed bin, 156 2 pad bit (36), 157 2 segptr (seg_count refer (seg_array.no_of_segs)) pointer; 158 159 dcl idle_values (total_intervals, no_of_fnps) fixed bin based (idle_value_ptr); 160 161 dcl 1 fnp_histogram_info aligned based (infop), 162 2 seg_array_ptr pointer, /* points to array of pointers to segments containing data for this FNP */ 163 2 total_segs fixed bin, 164 2 first_seg_of_interest fixed bin, /* index in seg_array of earliest segment we will use */ 165 2 last_seg_of_interest fixed bin; 166 167 dcl based_entname char (32) based; 168 169 170 /* ENTRIES */ 171 172 dcl define_area_ entry (ptr, fixed bin (35)); 173 dcl release_area_ entry (ptr); 174 dcl get_wdir_ entry returns (char (168)); 175 dcl cu_$arg_count entry (fixed bin, fixed bin (35)); 176 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 177 dcl com_err_ entry () options (variable); 178 dcl com_err_$suppress_name entry () options (variable); 179 dcl parse_fnp_name_ entry (char (*), fixed bin); 180 dcl cv_dec_check_ entry (char (*), fixed bin (35)) returns (fixed bin (35)); 181 dcl get_system_free_area_ entry () returns (ptr); 182 dcl expand_pathname_ entry (char (*), char (*), char (*), fixed bin (35)); 183 dcl hcs_$star_ entry (char (*), char (*), fixed bin (2), ptr, fixed bin, ptr, ptr, fixed bin (35)); 184 dcl hcs_$initiate entry (char (*), char (*), char (*), fixed bin (1), fixed bin (2), ptr, fixed bin (35)); 185 dcl pathname_ entry (char (*), char (*)) returns (char (168)); 186 dcl sort_items_$char entry (ptr, fixed bin (24)); 187 dcl hcs_$terminate_noname entry (ptr, fixed bin (35)); 188 dcl date_time_ entry (fixed bin (71), char (*)); 189 dcl ioa_ entry () options (variable); 190 dcl ioa_$rsnnl entry options (variable); 191 dcl get_line_length_$switch entry (ptr, fixed bin (35)) returns (fixed bin); 192 193 194 /* EXTERNAL STATIC */ 195 196 dcl ( 197 error_table_$inconsistent, 198 error_table_$noarg, 199 error_table_$badopt, 200 error_table_$nomatch 201 ) fixed bin (35) external static; 202 203 dcl sys_info$max_seg_size fixed bin (19) external static; 204 205 /* INTERNAL STATIC */ 206 207 dcl COMMAND_NAME char (16) internal static options (constant) init ("display_fnp_idle"); 208 dcl PERCENTS (10) fixed bin internal static options (constant) init (10, 20, 30, 40, 50, 60, 70, 80, 90, 100); 209 210 211 /* BUILTINS, CONDITIONS, ETC. */ 212 213 dcl cleanup condition; 214 215 dcl (addr, substr, sum, divide, null, max, float, fixed, empty, index) builtin; 216 217 dirname = get_wdir_ (); 218 hist, summary = "0"b; 219 from_time, to_time = 0; 220 minutes = 0; 221 line_length = 0; 222 fnp_names (*) = " "; 223 fnps (*) = "0"b; 224 fnpx = 0; 225 226 call cu_$arg_count (nargs, code); 227 if code ^= 0 228 then do; 229 call com_err_ (code, COMMAND_NAME); 230 return; 231 end; 232 233 if nargs = 0 234 then do; 235 call com_err_$suppress_name (0, COMMAND_NAME, 236 "Usage: display_fnp_idle -summary | -histogram {fnp_names} {-control_args}"); 237 return; 238 end; 239 240 do iarg = 1 to nargs; 241 call cu_$arg_ptr (iarg, argp, argl, code); 242 if code ^= 0 243 then do; 244 call com_err_ (code, COMMAND_NAME); 245 return; 246 end; 247 248 if substr (arg, 1, 1) ^= "-" /* not a control arg, must be an FNP name */ 249 then do; 250 call parse_fnp_name_ (arg, fnp_no); 251 if fnp_no < 0 252 then do; 253 call com_err_ (0, COMMAND_NAME, "^a is not a valid FNP name.", arg); 254 return; 255 end; 256 257 if fnps (fnp_no) 258 then do; 259 call com_err_ (error_table_$inconsistent, COMMAND_NAME, "FNP ^a specified more than once.", arg); 260 return; 261 end; 262 263 fnps (fnp_no) = "1"b; 264 fnpx = fnpx + 1; 265 fnp_names (fnpx) = arg; 266 end; 267 268 else do; 269 if arg = "-histogram" | arg = "-hist" 270 then if summary 271 then go to BOTH; 272 else hist = "1"b; 273 274 else if arg = "-summary" | arg = "-sum" 275 then if hist 276 then do; 277 BOTH: 278 call com_err_ (error_table_$inconsistent, COMMAND_NAME, 279 "Cannot specify both -histogram and -summary"); 280 return; 281 end; 282 283 else summary = "1"b; 284 285 else if arg = "-from" | arg = "-fm" 286 then from_time = get_time (arg); 287 288 else if arg = "-to" 289 then to_time = get_time (arg); 290 291 else if arg = "-interval" 292 then minutes = get_numeric_arg (arg); 293 294 else if arg = "-line_length" | arg = "-ll" 295 then do; 296 line_length = get_numeric_arg (arg); 297 if line_length < 38 298 then do; 299 call com_err_ (0, COMMAND_NAME, 300 "Specified line length of ^d is less than allowable minimum of 38.", line_length); 301 return; 302 end; 303 end; 304 305 else if arg = "-directory" | arg = "-dr" 306 then do; 307 iarg = iarg + 1; 308 call cu_$arg_ptr (iarg, argp, argl, code); 309 if code ^= 0 310 then do; 311 NO_DIR: 312 call com_err_ (code, COMMAND_NAME, "No directory pathname specified."); 313 return; 314 end; 315 316 if substr (arg, 1, 1) = "-" 317 then go to NO_DIR; 318 319 call expand_pathname_ (arg, dirname, entname, code); 320 if code ^= 0 321 then do; 322 call com_err_ (code, COMMAND_NAME, arg); 323 return; 324 end; 325 326 dirname = pathname_ (dirname, entname); 327 end; 328 329 else do; 330 call com_err_ (error_table_$badopt, COMMAND_NAME, arg); 331 return; 332 end; 333 end; 334 end; 335 336 if ^(hist | summary) 337 then do; 338 call com_err_ (error_table_$noarg, COMMAND_NAME, "one of -histogram or -summary must be specified."); 339 return; 340 end; 341 342 if to_time ^= 0 343 then if to_time <= from_time 344 then do; 345 call com_err_ (error_table_$inconsistent, COMMAND_NAME, 346 "Time specified by -to is not later than time specified by -from"); 347 return; 348 end; 349 350 if ^hist 351 then if minutes ^= 0 | line_length ^= 0 352 then call com_err_ (0, COMMAND_NAME, 353 "-interval and/or -line_length was specified without -histogram, and will be ignored."); 354 355 if fnpx = 0 /* no FNPs specified, so do them all */ 356 then fnps (*) = "1"b; 357 358 idle_value_ptr = null (); 359 earliest_of_all, latest_of_all = 0; 360 star_entry_ptr, star_names_ptr, names_array_ptr = null (); 361 362 363 area_infop = addr (auto_area_info); 364 area_info.version = area_info_version_1; 365 string (area_info.control) = "0"b; 366 area_info.owner = COMMAND_NAME; 367 area_info.size = sys_info$max_seg_size; 368 area_info.areap = null (); 369 370 call define_area_ (area_infop, code); 371 if code ^= 0 372 then do; 373 call com_err_ (code, COMMAND_NAME, "Could not define area."); 374 return; 375 end; 376 areap = area_info.areap; 377 the_area = empty (); 378 379 fnp_info_array (*).seg_array_ptr = null (); 380 on cleanup call clean_up_everything; 381 382 do i = 1 to 8; 383 if fnps (i) 384 then do; 385 infop = addr (fnp_info_array (i)); 386 fnp_name = substr ("abcdefgh", i, 1); 387 ok = "0"b; 388 seg_array_ptr = null (); 389 starname = "fnp_idle_data." || fnp_name || ".**"; 390 call hcs_$star_ (dirname, starname, star_BRANCHES_ONLY, areap, star_entry_count, star_entry_ptr, 391 star_names_ptr, code); 392 393 if code = error_table_$nomatch 394 then go to NO_DATA; 395 396 if code ^= 0 397 then call com_err_ (code, COMMAND_NAME, starname); 398 399 else do; 400 allocate names_array in (the_area) set (names_array_ptr); 401 do entryx = 1 to star_entry_count; 402 names_array.name_ptr (entryx) = addr (star_names (star_entries (entryx).nindex)); 403 end; 404 405 call sort_items_$char (names_array_ptr, 32); 406 fnp_histogram_info.total_segs = star_entry_count; 407 seg_count = star_entry_count; 408 allocate seg_array in (the_area) set (seg_array_ptr); 409 fnp_histogram_info.seg_array_ptr = seg_array_ptr; 410 earliest_found, latest_found = "0"b; 411 do segx = 1 to seg_count while (^latest_found); 412 entname = names_array.name_ptr (segx) -> based_entname; 413 call hcs_$initiate (dirname, entname, "", 0, 1, seg_array.segptr (segx), code); 414 415 if seg_array.segptr (segx) = null () 416 then call com_err_ (code, COMMAND_NAME, "Could not initiate ^a", 417 pathname_ (dirname, entname)); 418 419 else do; 420 fnp_idle_data_ptr = seg_array.segptr (segx); 421 if to_time ^= 0 422 then if fnp_idle_data.time_started > to_time 423 then do; 424 call hcs_$terminate_noname (fnp_idle_data_ptr, (0)); 425 seg_array.segptr (segx) = null (); 426 latest_found = "1"b; 427 go to NEXT_SEG; 428 end; 429 430 if ^earliest_found 431 then do; 432 if from_time ^= 0 433 then if fnp_idle_data.time_started <= from_time 434 then if fnp_idle_data.last_time <= from_time 435 then do; 436 call hcs_$terminate_noname (fnp_idle_data_ptr, (0)); 437 seg_array.segptr (segx) = null (); 438 go to NEXT_SEG; 439 end; 440 441 fnp_histogram_info.first_seg_of_interest = segx; 442 earliest_found = "1"b; 443 if earliest_of_all = 0 | fnp_idle_data.time_started < earliest_of_all 444 then earliest_of_all = fnp_idle_data.time_started; 445 end; 446 447 last_segx = segx; 448 last_start = fnp_idle_data.time_started; 449 last_finish = fnp_idle_data.last_time; 450 if to_time ^= 0 451 then if last_finish >= to_time 452 then latest_found = "1"b; 453 end; 454 NEXT_SEG: 455 end; 456 457 if ^earliest_found 458 then go to NO_DATA; 459 460 ok = "1"b; 461 latest_of_all = max (latest_of_all, to_time, last_finish); 462 fnp_histogram_info.last_seg_of_interest = last_segx; 463 464 if summary 465 then do; /* we can deal with this right now and be done with it */ 466 fnp_idle_data_ptr = seg_array.segptr (last_segx); 467 if to_time = 0 | fnp_idle_data.last_time <= to_time 468 then do; 469 last_entry = fnp_idle_data.entries_used; 470 closing_time = fnp_idle_data.last_time; 471 end; 472 473 else do; 474 last_entry = 475 fnp_idle_data.entries_used 476 - 477 divide (fnp_idle_data.last_time - to_time, fnp_idle_data.sample_interval, 17, 0); 478 closing_time = to_time; 479 end; 480 481 total_entries = last_entry; 482 beginning_found = "0"b; 483 first_segx, segx = last_segx; 484 first_entry = 0; 485 last_idle_count = fnp_idle_data.entries (last_entry).idle_count; 486 last_sample_count = fnp_idle_data.entries (last_entry).sample_count; 487 min_sample = fnp_idle_data.minimum_delta_idle; 488 minimum_time = fnp_idle_data.time_of_minimum_average; 489 min_idle = fnp_idle_data.minimum_idle_count; 490 min_idle_time = fnp_idle_data.time_of_minimum_sample; 491 492 do while (^beginning_found); 493 if from_time = 0 | fnp_idle_data.time_started > from_time 494 then do; 495 latest_beginning = fnp_idle_data.time_started; 496 do segx = segx - 1 to 1 by -1 while (seg_array.segptr (segx) = null ()); 497 end; 498 if segx < 1 499 then beginning_found = "1"b; 500 else do; 501 prev_fnp_idle_datap = fnp_idle_data_ptr; 502 /* in case we have to go back to it */ 503 fnp_idle_data_ptr = seg_array.segptr (segx); 504 if latest_beginning - fnp_idle_data.last_time 505 > fnp_idle_data.sample_interval + 30000000 506 /* 30-second fudge factor */ 507 then do; 508 beginning_found = "1"b; 509 fnp_idle_data_ptr = prev_fnp_idle_datap; 510 /* back to other segment */ 511 end; 512 513 else do; 514 total_entries = total_entries + fnp_idle_data.entries_used; 515 if fnp_idle_data.minimum_delta_idle < min_sample 516 & fnp_idle_data.time_of_minimum_average >= from_time 517 then do; 518 min_sample = fnp_idle_data.minimum_delta_idle; 519 minimum_time = fnp_idle_data.time_of_minimum_average; 520 end; 521 522 if fnp_idle_data.minimum_idle_count < min_idle 523 & fnp_idle_data.time_of_minimum_sample >= from_time 524 then do; 525 min_idle = fnp_idle_data.minimum_idle_count; 526 min_idle_time = fnp_idle_data.time_of_minimum_sample; 527 end; 528 end; 529 end; 530 end; 531 532 else do; 533 beginning_found = "1"b; 534 first_entry = 535 divide (from_time - fnp_idle_data.time_started, 536 fnp_idle_data.sample_interval, 17, 0); 537 total_entries = total_entries - first_entry; 538 end; 539 end; 540 541 first_entry = first_entry + 1; 542 if total_entries <= 1 | last_entry ^> first_entry 543 then go to NO_DATA; 544 545 opening_time = max (from_time, fnp_idle_data.time_started); 546 first_idle_count = fnp_idle_data.entries (first_entry).idle_count; 547 first_sample_count = fnp_idle_data.entries (first_entry).sample_count; 548 start_of_minimum_average = minimum_time - fnp_idle_data.sample_interval; 549 total_samples = last_sample_count - first_sample_count; 550 absolute_max = total_samples * fnp_idle_data.maximum_idle_count; 551 overall_average = 100 * float (last_idle_count - first_idle_count) / float (absolute_max); 552 553 call date_time_ (opening_time, start_time_string); 554 call date_time_ (closing_time, end_time_string); 555 start_string = substr (start_time_string, 1, 16); 556 if substr (end_time_string, 1, 8) = substr (start_time_string, 1, 8) 557 then end_string = substr (end_time_string, 11, 6); 558 else end_string = substr (end_time_string, 1, 16); 559 560 call ioa_ ("^/FNP ^a idle time from ^a to ^a: ^.1f%", fnp_name, start_string, end_string, 561 overall_average); 562 563 if start_of_minimum_average >= opening_time & minimum_time <= closing_time 564 then do; 565 average_sample = divide (total_samples, total_entries - 1, 35, 0); 566 minimum_average = 567 100 * float (min_sample) 568 / float (average_sample * fnp_idle_data.maximum_idle_count); 569 call date_time_ (start_of_minimum_average, min_start_string); 570 call date_time_ (minimum_time, min_end_string); 571 call ioa_ ("Busiest sample interval:^/^a to ^a: ^.1f% idle", 572 substr (min_start_string, 1, 16), substr (min_end_string, 11, 6), minimum_average) 573 ; 574 end; 575 576 if min_idle_time >= opening_time & min_idle_time <= closing_time 577 then do; 578 call date_time_ (min_idle_time, min_idle_string); 579 call ioa_ ("Busiest single sample: ^a: ^.1f% idle", substr (min_idle_string, 1, 16), 580 100 * float (min_idle) / float (fnp_idle_data.maximum_idle_count)); 581 end; 582 end; 583 584 if ^ok 585 then do; 586 NO_DATA: 587 if fnpx ^= 0 588 then call com_err_$suppress_name (0, COMMAND_NAME, "no data available for FNP ^a", fnp_name) 589 ; 590 if seg_array_ptr ^= null () 591 then call free_segs; 592 fnps (i) = "0"b; 593 end; 594 595 if star_names_ptr ^= null () 596 then do; 597 free star_names; 598 star_names_ptr = null (); 599 end; 600 601 if star_entry_ptr ^= null () 602 then do; 603 free star_entries; 604 star_entry_ptr = null (); 605 end; 606 607 if names_array_ptr ^= null () 608 then do; 609 free names_array; 610 names_array_ptr = null (); 611 end; 612 end; 613 end; 614 end; 615 616 if hist 617 then do; 618 if minutes = 0 619 then minutes = 15; /* default */ 620 hist_interval = 60000000 * minutes; /* convert to microseconds */ 621 622 if earliest_of_all < from_time 623 then earliest_of_all = from_time; 624 if to_time ^= 0 625 then if latest_of_all > to_time 626 then latest_of_all = to_time; 627 628 total_intervals = divide (latest_of_all - earliest_of_all, hist_interval, 17, 0); 629 no_of_fnps = 0; 630 do i = 1 to 8; 631 if fnps (i) 632 then no_of_fnps = no_of_fnps + 1; 633 end; 634 if no_of_fnps = 0 635 then go to ALL_DONE; 636 637 allocate idle_values in (the_area) set (idle_value_ptr); 638 idle_values (*, *) = -1; /* initialize to value indicating no data */ 639 fnpx = 0; 640 minimum_idle = 100; 641 642 do fnp_id = 1 to 8; 643 if fnps (fnp_id) 644 then do; 645 fnpx = fnpx + 1; 646 fnp_names (fnpx) = substr ("ABCDEFGH", fnp_id, 1); 647 infop = addr (fnp_info_array (fnp_id)); 648 seg_array_ptr = fnp_histogram_info.seg_array_ptr; 649 next_time = earliest_of_all; 650 valuex = 1; 651 residual = "0"b; 652 653 do segx = fnp_histogram_info.first_seg_of_interest 654 to fnp_histogram_info.last_seg_of_interest while (next_time < latest_of_all); 655 fnp_idle_data_ptr = seg_array.segptr (segx); 656 if fnp_idle_data_ptr = null () 657 then go to SCAN_NEXT_SEG; 658 659 if fnp_idle_data.last_time < next_time 660 then go to SCAN_NEXT_SEG; 661 662 entries_per_interval = divide (hist_interval, fnp_idle_data.sample_interval, 17, 0); 663 if entries_per_interval = 0 /* data is too sparse */ 664 then go to SCAN_NEXT_SEG; 665 666 last_time_in_seg = fnp_idle_data.last_time; 667 last_entry_in_seg = fnp_idle_data.entries_used; 668 max_idle = fnp_idle_data.maximum_idle_count; 669 if residual 670 then do; 671 if fnp_idle_data.sample_interval = last_interval 672 & fnp_idle_data.time_started - latest_time <= last_interval + 30000000 673 /* 30-second fudge factor */ 674 & fnp_idle_data.time_started > latest_time 675 then call store_value (last_origin, 676 addr (fnp_idle_data.entries (entries_per_interval - remaining_entries + 1))); 677 else call store_value (last_origin, end_of_last); 678 next_time = next_time + hist_interval; 679 residual = "0"b; 680 end; 681 682 if fnp_idle_data.time_started > next_time 683 then do; /* we have to skip some */ 684 valuex = 685 valuex + divide (fnp_idle_data.time_started - next_time, hist_interval, 17, 0); 686 next_time = fnp_idle_data.time_started; 687 first_entry = 1; 688 end; 689 690 else first_entry = 691 divide (next_time - fnp_idle_data.time_started, fnp_idle_data.sample_interval, 17, 692 0) + 1; 693 last_interval_start = last_entry_in_seg - entries_per_interval + 1; 694 time_to_stop = min (last_time_in_seg, latest_of_all); 695 696 do entryx = first_entry to last_interval_start by entries_per_interval 697 while (next_time < time_to_stop); 698 next_entryx = entryx + entries_per_interval; 699 if next_entryx <= last_entry_in_seg 700 then call store_value (addr (fnp_idle_data.entries (entryx)), 701 addr (fnp_idle_data.entries (next_entryx))); 702 next_time = next_time + hist_interval; 703 end; 704 705 if entryx < last_entry_in_seg & next_time < latest_of_all 706 then do; 707 residual = "1"b; 708 latest_time = last_time_in_seg; 709 last_origin = addr (fnp_idle_data.entries (entryx)); 710 end_of_last = addr (fnp_idle_data.entries (last_entry_in_seg)); 711 last_interval = fnp_idle_data.sample_interval; 712 remaining_entries = last_entry_in_seg - entryx + 1; 713 end; 714 SCAN_NEXT_SEG: 715 end; 716 end; 717 end; 718 719 /* now format it */ 720 721 if line_length = 0 722 then do; 723 line_length = get_line_length_$switch (null (), code); 724 if code ^= 0 725 then line_length = 80; 726 end; 727 728 scale_marks = max (10 - divide (minimum_idle, 10, 17, 0), 5); 729 top_of_scale = 10 * scale_marks; 730 hist_width = min (100, line_length - 17); 731 hist_width = hist_width - mod (hist_width, scale_marks); 732 cols_per_pct = float (hist_width) / float (top_of_scale); 733 734 space = divide (hist_width, scale_marks, 17, 0); 735 call ioa_$rsnnl ("^^9x%busy^^2x0^^^d(^^^dd^^)", ioa_str, ioa_strl, scale_marks, space); 736 call ioa_ (substr (ioa_str, 1, ioa_strl), PERCENTS); 737 call ioa_$rsnnl ("^^16x|^^^d(^^^dx|^^)", ioa_str, ioa_strl, scale_marks, space - 1); 738 call ioa_ (substr (ioa_str, 1, ioa_strl)); 739 740 any = "0"b; 741 prev_date = " "; 742 cur_time = earliest_of_all; 743 suppressed (*) = 0; 744 745 do line = 1 to total_intervals; 746 cells = 0; 747 do fnp_no = 1 to no_of_fnps; 748 if idle_values (line, fnp_no) ^= -1 749 then do; 750 cells = cells + 1; 751 output.column (cells) = 17 + fixed (cols_per_pct * (100 - idle_values (line, fnp_no))); 752 output.name (cells) = fnp_names (fnp_no); 753 end; 754 end; 755 756 if cells = 0 757 then if any 758 then if last_had_data 759 then do; 760 call ioa_ ("^16(-^)"); 761 last_had_data = "0"b; 762 end; 763 else ; 764 else ; 765 766 else do; 767 any = "1"b; 768 last_had_data = "1"b; 769 output_line = " "; 770 call date_time_ (cur_time, dt_string); 771 if substr (dt_string, 1, 8) ^= prev_date 772 then prev_date, substr (output_line, 1, 8) = substr (dt_string, 1, 8); 773 substr (output_line, 10, 5) = substr (dt_string, 11, 5); 774 775 do i = 1 to cells; 776 cur_column = output (i).column; 777 if substr (output_line, cur_column, 1) = " " 778 then substr (output_line, cur_column, 1) = output (i).name; 779 else do; 780 already = index ("ABCDEFGH", substr (output_line, cur_column, 1)); 781 new = index ("ABCDEFGH", output (i).name); 782 if suppressed (already) >= suppressed (new) 783 then suppressed (new) = suppressed (new) + 1; 784 else do; 785 substr (output_line, cur_column, 1) = output (i).name; 786 suppressed (already) = suppressed (already) + 1; 787 end; 788 end; 789 end; 790 791 call ioa_ (output_line); 792 end; 793 794 cur_time = cur_time + hist_interval; 795 end; 796 end; 797 798 ALL_DONE: 799 call clean_up_everything; 800 EXIT: 801 return; 802 803 get_numeric_arg: 804 procedure (name) returns (fixed bin); 805 806 dcl name char (*); 807 dcl result fixed bin; 808 809 iarg = iarg + 1; 810 call cu_$arg_ptr (iarg, argp, argl, code); 811 if code ^= 0 812 then do; 813 NO_NUMERIC_ARG: 814 call com_err_ (code, COMMAND_NAME, "No value specified for ^a.", name); 815 go to EXIT; 816 end; 817 818 else if substr (arg, 1, 1) = "-" 819 then do; 820 code = error_table_$noarg; 821 go to NO_NUMERIC_ARG; 822 end; 823 824 result = cv_dec_check_ (arg, code); 825 if code ^= 0 826 then do; 827 call com_err_ (0, COMMAND_NAME, "^a is not a valid value for ^a.", arg, name); 828 go to EXIT; 829 end; 830 831 return (result); 832 end get_numeric_arg; 833 834 get_time: 835 procedure (arg_name) returns (fixed bin (71)); 836 837 dcl arg_name char (*); 838 dcl time fixed bin (71); 839 dcl convert_date_to_binary_ entry (char (*), fixed bin (71), fixed bin (35)); 840 841 iarg = iarg + 1; 842 call cu_$arg_ptr (iarg, argp, argl, code); 843 if code ^= 0 844 then do; 845 call com_err_ (code, COMMAND_NAME, "No value supplied for ^a", arg_name); 846 go to EXIT; 847 end; 848 849 call convert_date_to_binary_ (arg, time, code); 850 if code ^= 0 851 then do; 852 call com_err_ (code, COMMAND_NAME, """^a"" is not a valid time.", arg); 853 go to EXIT; 854 end; 855 856 else return (time); 857 858 end get_time; 859 860 store_value: 861 procedure (first_entryp, last_entryp); 862 863 dcl first_entryp pointer; 864 dcl last_entryp pointer; 865 866 dcl delta_sample fixed bin (35); 867 dcl max_possible fixed bin (35); 868 dcl value fixed bin; 869 870 delta_sample = last_entryp -> fnp_idle_entry.sample_count - first_entryp -> fnp_idle_entry.sample_count; 871 max_possible = delta_sample * max_idle; 872 value = 873 divide (100 * (last_entryp -> fnp_idle_entry.idle_count - first_entryp -> fnp_idle_entry.idle_count), 874 max_possible, 17, 0); 875 idle_values (valuex, fnpx) = value; 876 if value < minimum_idle 877 then minimum_idle = value; 878 valuex = valuex + 1; 879 return; 880 881 end store_value; 882 883 clean_up_everything: 884 procedure; 885 886 dcl infox fixed bin; 887 888 do infox = 1 to 8; 889 if fnps (infox) 890 then do; 891 infop = addr (fnp_info_array (infox)); 892 seg_array_ptr = fnp_histogram_info.seg_array_ptr; 893 if seg_array_ptr ^= null () 894 then call free_segs; 895 end; 896 end; 897 898 if idle_value_ptr ^= null () 899 then free idle_values; 900 901 if star_names_ptr ^= null () 902 then free star_names; 903 904 if star_entry_ptr ^= null () 905 then free star_entries; 906 907 if names_array_ptr ^= null () 908 then free names_array; 909 910 idle_value_ptr, star_entry_ptr, star_names_ptr, names_array_ptr = null (); 911 call release_area_ (areap); 912 return; 913 914 end clean_up_everything; 915 916 free_segs: 917 procedure; 918 919 do segx = 1 to seg_array.no_of_segs; 920 if seg_array.segptr (segx) ^= null () 921 then call hcs_$terminate_noname (seg_array.segptr (segx), (0)); 922 end; 923 free seg_array_ptr -> seg_array; 924 seg_array_ptr, fnp_histogram_info.seg_array_ptr = null (); 925 return; 926 927 end free_segs; 928 1 1 /* BEGIN INCLUDE FILE...fnp_idle_data.incl.pl1 */ 1 2 1 3 /* This include file defines the structure used by meter_fnp_idle to accumulate 1 4* data reported by display_fnp_idle */ 1 5 1 6 /* Written January 7, 1982 by Robert S. Coren */ 1 7 1 8 dcl 1 fnp_idle_data aligned based (fnp_idle_data_ptr), 1 9 2 version fixed bin, 1 10 2 sample_interval fixed bin, /* in microseconds */ 1 11 2 time_started fixed bin (71), /* clock time when metering started */ 1 12 2 last_time fixed bin (71), /* time of most recent entry */ 1 13 2 time_of_minimum_sample fixed bin (71), /* time at which new minimum idle count was reported */ 1 14 2 time_of_minimum_average fixed bin (71), /* time of interval that had smallest net idle */ 1 15 2 minimum_idle_count fixed bin (35), /* count for busiest second */ 1 16 2 minimum_delta_idle fixed bin (35), /* idle count accumulated during busiest sample_interval */ 1 17 2 maximum_idle_count fixed bin (35), /* 100% idle value */ 1 18 2 latest_idle_count fixed bin (35), /* idle count most recently recorded */ 1 19 2 latest_sample_count fixed bin (35), /* number of updates during last interval */ 1 20 2 max_entries fixed bin, /* the largest number of entries that can be recorded in this segment */ 1 21 2 entries_used fixed bin, /* the number of entries that have been recorded so far */ 1 22 2 pad bit (36), /* make entries double_word aligned for neatness */ 1 23 2 entries (max_fnp_idle_entries refer (fnp_idle_data.max_entries)) like fnp_idle_entry; 1 24 1 25 dcl 1 fnp_idle_entry aligned based, 1 26 2 idle_count fixed bin (35), /* accumulated idle count reported by FNP */ 1 27 2 sample_count fixed bin (35); /* number of updates represented by idle_count */ 1 28 1 29 dcl max_fnp_idle_entries fixed bin; 1 30 dcl fnp_idle_data_ptr pointer; 1 31 1 32 dcl FNP_IDLE_DATA_VERSION_1 fixed bin internal static options (constant) init (1); 1 33 1 34 /* END INCLUDE FILE ... fnp_idle_data.incl.pl1 */ 929 930 2 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 2 2 2 3 /* This include file contains structures for the hcs_$star_, 2 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 2 5* 2 6* Written 23 October 1978 by Monte Davidoff. 2 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 2 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 2 9**/ 2 10 2 11 /* automatic */ 2 12 2 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 2 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 2 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 2 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 2 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 2 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 2 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 2 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 2 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 2 22 2 23 /* based */ 2 24 2 25 /* hcs_$star_ entry structure */ 2 26 2 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 2 28 2 type fixed binary (2) unsigned unaligned, 2 29 /* storage system type */ 2 30 2 nnames fixed binary (16) unsigned unaligned, 2 31 /* number of names of entry that match star_name */ 2 32 2 nindex fixed binary (18) unsigned unaligned; 2 33 /* index of first name in star_names */ 2 34 2 35 /* hcs_$star_ name structure */ 2 36 2 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 2 38 2 39 /* hcs_$star_list_ branch structure */ 2 40 2 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 42 2 type fixed binary (2) unsigned unaligned, 2 43 /* storage system type */ 2 44 2 nnames fixed binary (16) unsigned unaligned, 2 45 /* number of names of entry that match star_name */ 2 46 2 nindex fixed binary (18) unsigned unaligned, 2 47 /* index of first name in star_list_names */ 2 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 2 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 2 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 53 2 pad bit (7) unaligned, 2 54 2 records fixed binary (18) unsigned unaligned; 2 55 /* records used by branch */ 2 56 2 57 /* hcs_$star_dir_list_ branch structure */ 2 58 2 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 60 2 type fixed binary (2) unsigned unaligned, 2 61 /* storage system type */ 2 62 2 nnames fixed binary (16) unsigned unaligned, 2 63 /* number of names of entry that match star_name */ 2 64 2 nindex fixed binary (18) unsigned unaligned, 2 65 /* index of first name in star_list_names */ 2 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 2 67 2 pad bit (36) unaligned, 2 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 71 2 bit_count fixed binary (24) unaligned; 2 72 /* bit count of the branch */ 2 73 2 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 2 75 2 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 77 2 type fixed binary (2) unsigned unaligned, 2 78 /* storage system type */ 2 79 2 nnames fixed binary (16) unsigned unaligned, 2 80 /* number of names of entry that match star_name */ 2 81 2 nindex fixed binary (18) unsigned unaligned, 2 82 /* index of first name in star_list_names */ 2 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 2 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 2 85 2 pathname_len fixed binary (18) unsigned unaligned, 2 86 /* length of the pathname of the link */ 2 87 2 pathname_index fixed binary (18) unsigned unaligned; 2 88 /* index of start of pathname in star_list_names */ 2 89 2 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 2 91 2 92 declare star_list_names char (32) based (star_list_names_ptr) 2 93 dimension (star_links (star_branch_count + star_link_count).nindex 2 94 + star_links (star_branch_count + star_link_count).nnames 2 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 2 96 * binary ( 2 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 2 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 2 99 2 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 2 101 2 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 2 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 2 104 2 105 /* internal static */ 2 106 2 107 /* star_select_sw values */ 2 108 2 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 2 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 2 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 2 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 2 113 fixed binary (3) internal static options (constant) initial (5); 2 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 2 115 fixed binary (3) internal static options (constant) initial (7); 2 116 2 117 /* storage system types */ 2 118 2 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 2 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 2 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 2 122 2 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 931 932 3 1 /* BEGIN INCLUDE FILE area_info.incl.pl1 12/75 */ 3 2 3 3 dcl area_info_version_1 fixed bin static init (1) options (constant); 3 4 3 5 dcl area_infop ptr; 3 6 3 7 dcl 1 area_info aligned based (area_infop), 3 8 2 version fixed bin, /* version number for this structure is 1 */ 3 9 2 control aligned like area_control, /* control bits for the area */ 3 10 2 owner char (32) unal, /* creator of the area */ 3 11 2 n_components fixed bin, /* number of components in the area (returned only) */ 3 12 2 size fixed bin (18), /* size of the area in words */ 3 13 2 version_of_area fixed bin, /* version of area (returned only) */ 3 14 2 areap ptr, /* pointer to the area (first component on multisegment area) */ 3 15 2 allocated_blocks fixed bin, /* number of blocks allocated */ 3 16 2 free_blocks fixed bin, /* number of free blocks not in virgin */ 3 17 2 allocated_words fixed bin (30), /* number of words allocated in the area */ 3 18 2 free_words fixed bin (30); /* number of words free in area not in virgin */ 3 19 3 20 dcl 1 area_control aligned based, 3 21 2 extend bit (1) unal, /* says area is extensible */ 3 22 2 zero_on_alloc bit (1) unal, /* says block gets zerod at allocation time */ 3 23 2 zero_on_free bit (1) unal, /* says block gets zerod at free time */ 3 24 2 dont_free bit (1) unal, /* debugging aid, turns off free requests */ 3 25 2 no_freeing bit (1) unal, /* for allocation method without freeing */ 3 26 2 system bit (1) unal, /* says area is managed by system */ 3 27 2 pad bit (30) unal; 3 28 3 29 /* END INCLUDE FILE area_info.incl.pl1 */ 933 934 935 end display_fnp_idle; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/15/82 1449.1 display_fnp_idle.pl1 >dumps>old>recomp>display_fnp_idle.pl1 929 1 03/26/82 1716.4 fnp_idle_data.incl.pl1 >ldd>include>fnp_idle_data.incl.pl1 931 2 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.incl.pl1 933 3 06/11/76 1043.4 area_info.incl.pl1 >ldd>include>area_info.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. COMMAND_NAME 000012 constant char(16) initial unaligned dcl 207 set ref 229* 235* 244* 253* 259* 277* 299* 311* 322* 330* 338* 345* 350* 366 373* 396* 415* 586* 813* 827* 845* 852* PERCENTS 000000 constant fixed bin(17,0) initial array dcl 208 set ref 736* absolute_max 000301 automatic fixed bin(35,0) dcl 76 set ref 550* 551 addr builtin function dcl 215 ref 363 385 402 647 671 671 699 699 699 699 709 710 891 already 000506 automatic fixed bin(17,0) dcl 121 set ref 780* 782 786 786 any 000421 automatic bit(1) unaligned dcl 111 set ref 740* 756 767* area_control based structure level 1 dcl 3-20 area_info based structure level 1 dcl 3-7 area_info_version_1 constant fixed bin(17,0) initial dcl 3-3 ref 364 area_infop 000670 automatic pointer dcl 3-5 set ref 363* 364 365 366 367 368 370* 376 areap 16 based pointer level 2 in structure "area_info" dcl 3-7 in procedure "display_fnp_idle" set ref 368* 376 areap 000174 automatic pointer dcl 39 in procedure "display_fnp_idle" set ref 376* 377 390* 400 408 637 911* arg based char unaligned dcl 141 set ref 248 250* 253* 259* 265 269 269 274 274 285 285 285* 288 288* 291 291* 294 294 296* 305 305 316 319* 322* 330* 818 824* 827* 849* 852* arg_name parameter char unaligned dcl 837 set ref 834 845* argl 000624 automatic fixed bin(21,0) dcl 140 set ref 241* 248 250 250 253 253 259 259 265 269 269 274 274 285 285 285 285 288 288 288 291 291 291 294 294 296 296 305 305 308* 316 319 319 322 322 330 330 810* 818 824 824 827 827 842* 849 849 852 852 argp 000622 automatic pointer dcl 139 set ref 241* 248 250 253 259 265 269 269 274 274 285 285 285 288 288 291 291 294 294 296 305 305 308* 316 319 322 330 810* 818 824 827 842* 849 852 auto_area_info 000626 automatic structure level 1 dcl 148 set ref 363 average_sample 000327 automatic fixed bin(35,0) dcl 82 set ref 565* 566 based_entname based char(32) unaligned dcl 167 ref 412 beginning_found 000253 automatic bit(1) unaligned dcl 61 set ref 482* 492 498* 508* 533* cells 000437 automatic fixed bin(17,0) dcl 116 set ref 746* 750* 750 751 752 756 775 cleanup 000652 stack reference condition dcl 213 ref 380 closing_time 000246 automatic fixed bin(71,0) dcl 58 set ref 470* 478* 554* 563 576 code 000162 automatic fixed bin(35,0) dcl 32 set ref 226* 227 229* 241* 242 244* 308* 309 311* 319* 320 322* 370* 371 373* 390* 393 396 396* 413* 415* 723* 724 810* 811 813* 820* 824* 825 842* 843 845* 849* 850 852* cols_per_pct 000406 automatic float bin(27) dcl 107 set ref 732* 751 column 000510 automatic fixed bin(17,0) array level 2 dcl 124 set ref 751* 776 com_err_ 000022 constant entry external dcl 177 ref 229 244 253 259 277 299 311 322 330 338 345 350 373 396 415 813 827 845 852 com_err_$suppress_name 000024 constant entry external dcl 178 ref 235 586 control 1 based structure level 2 dcl 3-7 set ref 365* convert_date_to_binary_ 000070 constant entry external dcl 839 ref 849 cu_$arg_count 000016 constant entry external dcl 175 ref 226 cu_$arg_ptr 000020 constant entry external dcl 176 ref 241 308 810 842 cur_column 000505 automatic fixed bin(17,0) dcl 120 set ref 776* 777 777 780 785 cur_time 000424 automatic fixed bin(71,0) dcl 113 set ref 742* 770* 794* 794 cv_dec_check_ 000030 constant entry external dcl 180 ref 824 date_time_ 000046 constant entry external dcl 188 ref 553 554 569 570 578 770 define_area_ 000010 constant entry external dcl 172 ref 370 delta_sample 000740 automatic fixed bin(35,0) dcl 866 set ref 870* 871 dirname 000100 automatic char(168) unaligned dcl 25 set ref 217* 319* 326* 326* 390* 413* 415* 415* divide builtin function dcl 215 ref 474 534 565 628 662 684 690 728 734 872 dt_string 000477 automatic char(24) unaligned dcl 119 set ref 770* 771 771 773 earliest_found 000216 automatic bit(1) unaligned dcl 47 set ref 410* 430 442* 457 earliest_of_all 000176 automatic fixed bin(71,0) dcl 40 set ref 359* 443 443 443* 622 622* 628 649 742 empty builtin function dcl 215 ref 377 end_of_last 000376 automatic pointer dcl 101 set ref 677* 710* end_string 000323 automatic char(16) unaligned dcl 81 set ref 556* 558* 560* end_time_string 000311 automatic char(24) unaligned dcl 79 set ref 554* 556 556 558 entname 000221 automatic char(32) unaligned dcl 50 set ref 319* 326* 412* 413* 415* 415* entries 22 based structure array level 2 dcl 1-8 set ref 671 671 699 699 699 699 709 710 entries_per_interval 000366 automatic fixed bin(17,0) dcl 95 set ref 662* 663 671 671 693 696 698 entries_used 20 based fixed bin(17,0) level 2 dcl 1-8 ref 469 474 514 667 entryx 000215 automatic fixed bin(17,0) dcl 46 set ref 401* 402 402* 696* 698 699 699* 705 709 712 error_table_$badopt 000062 external static fixed bin(35,0) dcl 196 set ref 330* error_table_$inconsistent 000056 external static fixed bin(35,0) dcl 196 set ref 259* 277* 345* error_table_$noarg 000060 external static fixed bin(35,0) dcl 196 set ref 338* 820 error_table_$nomatch 000064 external static fixed bin(35,0) dcl 196 ref 393 expand_pathname_ 000032 constant entry external dcl 182 ref 319 first_entry 000257 automatic fixed bin(17,0) dcl 64 set ref 484* 534* 537 541* 541 542 546 547 687* 690* 696 first_entryp parameter pointer dcl 863 ref 860 870 872 first_idle_count 000260 automatic fixed bin(35,0) dcl 65 set ref 546* 551 first_sample_count 000261 automatic fixed bin(35,0) dcl 66 set ref 547* 549 first_seg_of_interest 3 based fixed bin(17,0) level 2 dcl 161 set ref 441* 653 first_segx 000256 automatic fixed bin(17,0) dcl 63 set ref 483* fixed builtin function dcl 215 ref 751 float builtin function dcl 215 ref 551 551 566 566 579 579 732 732 fnp_histogram_info based structure level 1 dcl 161 fnp_id 000361 automatic fixed bin(17,0) dcl 91 set ref 642* 643 646 647* fnp_idle_data based structure level 1 dcl 1-8 fnp_idle_data_ptr 000660 automatic pointer dcl 1-30 set ref 420* 421 424* 432 432 436* 443 443 448 449 466* 467 469 470 474 474 474 485 486 487 488 489 490 493 495 501 503* 504 504 509* 514 515 515 518 519 522 522 525 526 534 534 545 546 547 548 550 566 579 655* 656 659 662 666 667 668 671 671 671 671 671 682 684 686 690 690 699 699 699 699 709 710 711 fnp_idle_entry based structure level 1 dcl 1-25 fnp_info_array 000530 automatic structure array level 1 dcl 128 set ref 385 647 891 fnp_name 000202 automatic char(1) unaligned dcl 42 set ref 386* 389 560* 586* fnp_names 000164 automatic char(1) array unaligned dcl 33 set ref 222* 265* 646* 752 fnp_no 000172 automatic fixed bin(17,0) dcl 38 set ref 250* 251 257 263 747* 748 751 752* fnps 000166 automatic bit(1) array unaligned dcl 34 set ref 223* 257 263* 355* 383 592* 631 643 889 fnpx 000167 automatic fixed bin(17,0) dcl 35 set ref 224* 264* 264 265 355 586 639* 645* 645 646 875 from_time 000154 automatic fixed bin(71,0) dcl 28 set ref 219* 285* 342 432 432 432 493 493 515 522 534 545 622 622 get_line_length_$switch 000054 constant entry external dcl 191 ref 723 get_wdir_ 000014 constant entry external dcl 174 ref 217 hcs_$initiate 000036 constant entry external dcl 184 ref 413 hcs_$star_ 000034 constant entry external dcl 183 ref 390 hcs_$terminate_noname 000044 constant entry external dcl 187 ref 424 436 920 hist 000152 automatic bit(1) unaligned dcl 26 set ref 218* 272* 274 336 350 616 hist_interval 000354 automatic fixed bin(71,0) dcl 87 set ref 620* 628 662 678 684 702 794 hist_width 000405 automatic fixed bin(17,0) dcl 106 set ref 730* 731* 731 731 732 734 i 000203 automatic fixed bin(17,0) dcl 43 set ref 382* 383 385 386 592* 630* 631* 775* 776 777 781 785* iarg 000171 automatic fixed bin(17,0) dcl 37 set ref 240* 241* 307* 307 308* 809* 809 810* 841* 841 842* idle_count based fixed bin(35,0) level 2 in structure "fnp_idle_entry" dcl 1-25 in procedure "display_fnp_idle" ref 872 872 idle_count 22 based fixed bin(35,0) array level 3 in structure "fnp_idle_data" dcl 1-8 in procedure "display_fnp_idle" set ref 485 546 idle_value_ptr 000616 automatic pointer dcl 133 set ref 358* 637* 638 748 751 875 898 898 910* idle_values based fixed bin(17,0) array dcl 159 set ref 637 638* 748 751 875* 898 index builtin function dcl 215 ref 780 781 infop 000620 automatic pointer dcl 134 set ref 385* 406 409 441 462 647* 648 653 653 891* 892 924 infox 000100 automatic fixed bin(17,0) dcl 886 set ref 888* 889 891* ioa_ 000050 constant entry external dcl 189 ref 560 571 579 736 738 760 791 ioa_$rsnnl 000052 constant entry external dcl 190 ref 735 737 ioa_str 000410 automatic char(32) unaligned dcl 109 set ref 735* 736 736 737* 738 738 ioa_strl 000420 automatic fixed bin(17,0) dcl 110 set ref 735* 736 736 737* 738 738 last_entry 000236 automatic fixed bin(17,0) dcl 54 set ref 469* 474* 481 485 486 542 last_entry_in_seg 000242 automatic fixed bin(17,0) dcl 56 set ref 667* 693 699 705 710 712 last_entryp parameter pointer dcl 864 ref 860 870 872 last_finish 000234 automatic fixed bin(71,0) dcl 53 set ref 449* 450 461 last_had_data 000440 automatic bit(1) unaligned dcl 117 set ref 756 761* 768* last_idle_count 000262 automatic fixed bin(35,0) dcl 67 set ref 485* 551 last_interval 000400 automatic fixed bin(71,0) dcl 102 set ref 671 671 711* last_interval_start 000367 automatic fixed bin(17,0) dcl 96 set ref 693* 696 last_origin 000374 automatic pointer dcl 100 set ref 671* 677* 709* last_sample_count 000263 automatic fixed bin(35,0) dcl 68 set ref 486* 549 last_seg_of_interest 4 based fixed bin(17,0) level 2 dcl 161 set ref 462* 653 last_segx 000231 automatic fixed bin(17,0) dcl 51 set ref 447* 462 466 483 last_start 000232 automatic fixed bin(71,0) dcl 52 set ref 448* last_time 4 based fixed bin(71,0) level 2 dcl 1-8 ref 432 449 467 470 474 504 659 666 last_time_in_seg 000240 automatic fixed bin(71,0) dcl 55 set ref 666* 694 708 latest_beginning 000264 automatic fixed bin(71,0) dcl 69 set ref 495* 504 latest_found 000217 automatic bit(1) unaligned dcl 48 set ref 410* 411 426* 450* latest_of_all 000200 automatic fixed bin(71,0) dcl 41 set ref 359* 461* 461 624 624* 628 653 694 705 latest_time 000372 automatic fixed bin(71,0) dcl 99 set ref 671 671 708* line 000436 automatic fixed bin(17,0) dcl 115 set ref 745* 748 751* line_length 000161 automatic fixed bin(17,0) dcl 31 set ref 221* 296* 297 299* 350 721 723* 724* 730 max builtin function dcl 215 ref 461 545 728 max_idle 000370 automatic fixed bin(35,0) dcl 97 set ref 668* 871 max_possible 000741 automatic fixed bin(35,0) dcl 867 set ref 871* 872 maximum_idle_count 14 based fixed bin(35,0) level 2 dcl 1-8 ref 550 566 579 668 min_end_string 000337 automatic char(24) unaligned dcl 85 set ref 570* 571 571 min_idle 000274 automatic fixed bin(35,0) dcl 73 set ref 489* 522 525* 579 min_idle_string 000345 automatic char(24) unaligned dcl 86 set ref 578* 579 579 min_idle_time 000276 automatic fixed bin(71,0) dcl 74 set ref 490* 526* 576 576 578* min_sample 000266 automatic fixed bin(35,0) dcl 70 set ref 487* 515 518* 566 min_start_string 000331 automatic char(24) unaligned dcl 84 set ref 569* 571 571 minimum_average 000330 automatic float bin(27) dcl 83 set ref 566* 571* minimum_delta_idle 13 based fixed bin(35,0) level 2 dcl 1-8 ref 487 515 518 minimum_idle 000360 automatic fixed bin(17,0) dcl 90 set ref 640* 728 876 876* minimum_idle_count 12 based fixed bin(35,0) level 2 dcl 1-8 ref 489 522 525 minimum_time 000270 automatic fixed bin(71,0) dcl 71 set ref 488* 519* 548 563 570* minutes 000160 automatic fixed bin(17,0) dcl 30 set ref 220* 291* 350 618 618* 620 n_names based fixed bin(17,0) level 2 dcl 150 set ref 400* 609 907 name 1 000510 automatic char(1) array level 2 in structure "output" dcl 124 in procedure "display_fnp_idle" set ref 752* 777 781 785 name parameter char unaligned dcl 806 in procedure "get_numeric_arg" set ref 803 813* 827* name_ptr 1 based pointer array level 2 packed unaligned dcl 150 set ref 402* 412 names_array based structure level 1 dcl 150 set ref 400 609 907 names_array_ptr 000610 automatic pointer dcl 130 set ref 360* 400* 402 405* 412 607 609 610* 907 907 910* nargs 000170 automatic fixed bin(17,0) dcl 36 set ref 226* 233 240 new 000507 automatic fixed bin(17,0) dcl 122 set ref 781* 782 782 782 next_entryx 000371 automatic fixed bin(17,0) dcl 98 set ref 698* 699 699 699 next_time 000362 automatic fixed bin(71,0) dcl 92 set ref 649* 653 659 678* 678 682 684 686* 690 696 702* 702 705 nindex 0(18) based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 2-27 ref 402 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 2-27 ref 597 901 no_of_fnps 000357 automatic fixed bin(17,0) dcl 89 set ref 629* 631* 631 634 637 638 638 638 747 748 748 751 751 875 875 898 no_of_segs based fixed bin(17,0) level 2 dcl 154 set ref 408* 919 923 null builtin function dcl 215 ref 358 360 368 379 388 415 425 437 496 590 595 598 601 604 607 610 656 723 723 893 898 901 904 907 910 920 924 ok 000204 automatic bit(1) unaligned dcl 44 set ref 387* 460* 584 opening_time 000244 automatic fixed bin(71,0) dcl 57 set ref 545* 553* 563 576 output 000510 automatic structure array level 1 dcl 124 output_line 000441 automatic char(120) unaligned dcl 118 set ref 769* 771* 773* 777 777* 780 785* 791* overall_average 000302 automatic float bin(27) dcl 77 set ref 551* 560* owner 2 based char(32) level 2 packed unaligned dcl 3-7 set ref 366* parse_fnp_name_ 000026 constant entry external dcl 179 ref 250 pathname_ 000040 constant entry external dcl 185 ref 326 415 415 prev_date 000422 automatic char(8) unaligned dcl 112 set ref 741* 771 771* prev_fnp_idle_datap 000254 automatic pointer dcl 62 set ref 501* 509 release_area_ 000012 constant entry external dcl 173 ref 911 remaining_entries 000402 automatic fixed bin(17,0) dcl 103 set ref 671 671 712* residual 000365 automatic bit(1) unaligned dcl 94 set ref 651* 669 679* 707* result 000720 automatic fixed bin(17,0) dcl 807 set ref 824* 831 sample_count 23 based fixed bin(35,0) array level 3 in structure "fnp_idle_data" dcl 1-8 in procedure "display_fnp_idle" set ref 486 547 sample_count 1 based fixed bin(35,0) level 2 in structure "fnp_idle_entry" dcl 1-25 in procedure "display_fnp_idle" ref 870 870 sample_interval 1 based fixed bin(17,0) level 2 dcl 1-8 ref 474 504 534 548 662 671 690 711 scale_marks 000403 automatic fixed bin(17,0) dcl 104 set ref 728* 729 731 734 735* 737* seg_array based structure level 1 dcl 154 set ref 408 923 seg_array_ptr 000530 automatic pointer array level 2 in structure "fnp_info_array" dcl 128 in procedure "display_fnp_idle" set ref 379* seg_array_ptr 000612 automatic pointer dcl 131 in procedure "display_fnp_idle" set ref 388* 408* 409 413 415 420 425 437 466 496 503 590 648* 655 892* 893 919 920 920 923 924* seg_array_ptr based pointer level 2 in structure "fnp_histogram_info" dcl 161 in procedure "display_fnp_idle" set ref 409* 648 892 924* seg_count 000614 automatic fixed bin(17,0) dcl 132 set ref 407* 408 408 411 segptr 2 based pointer array level 2 dcl 154 set ref 413* 415 420 425* 437* 466 496 503 655 920 920* segx 000220 automatic fixed bin(17,0) dcl 49 set ref 411* 412 413 415 420 425 437 441 447* 483* 496* 496 496* 498 503 653* 655* 919* 920 920* size 13 based fixed bin(18,0) level 2 dcl 3-7 set ref 367* sort_items_$char 000042 constant entry external dcl 186 ref 405 space 000407 automatic fixed bin(17,0) dcl 108 set ref 734* 735* 737 star_BRANCHES_ONLY 000077 constant fixed bin(2,0) initial dcl 2-110 set ref 390* star_entries based structure array level 1 dcl 2-27 ref 603 904 star_entry_count 000662 automatic fixed bin(17,0) dcl 2-14 set ref 390* 400 400 401 406 407 597 603 901 904 star_entry_ptr 000664 automatic pointer dcl 2-15 set ref 360* 390* 402 597 601 603 604* 901 904 904 910* star_names based char(32) array unaligned dcl 2-37 set ref 402 597 901 star_names_ptr 000666 automatic pointer dcl 2-19 set ref 360* 390* 402 595 597 598* 901 901 910* starname 000205 automatic char(32) unaligned dcl 45 set ref 389* 390* 396* start_of_minimum_average 000272 automatic fixed bin(71,0) dcl 72 set ref 548* 563 569* start_string 000317 automatic char(16) unaligned dcl 80 set ref 555* 560* start_time_string 000303 automatic char(24) unaligned dcl 78 set ref 553* 555 556 substr builtin function dcl 215 set ref 248 316 386 555 556 556 556 558 571 571 571 571 579 579 646 736 736 738 738 771 771 771* 773* 773 777 777* 780 785* 818 sum builtin function dcl 215 ref 597 901 summary 000153 automatic bit(1) unaligned dcl 27 set ref 218* 269 283* 336 464 suppressed 000426 automatic fixed bin(17,0) array dcl 114 set ref 743* 782 782 782* 782 786* 786 sys_info$max_seg_size 000066 external static fixed bin(19,0) dcl 203 ref 367 the_area based area(261120) dcl 146 set ref 377* 400 408 637 time 000730 automatic fixed bin(71,0) dcl 838 set ref 849* 856 time_of_minimum_average 10 based fixed bin(71,0) level 2 dcl 1-8 ref 488 515 519 time_of_minimum_sample 6 based fixed bin(71,0) level 2 dcl 1-8 ref 490 522 526 time_started 2 based fixed bin(71,0) level 2 dcl 1-8 ref 421 432 443 443 448 493 495 534 545 671 671 682 684 686 690 time_to_stop 000250 automatic fixed bin(71,0) dcl 59 set ref 694* 696 to_time 000156 automatic fixed bin(71,0) dcl 29 set ref 219* 288* 342 342 421 421 450 450 461 467 467 474 478 624 624 624 top_of_scale 000404 automatic fixed bin(17,0) dcl 105 set ref 729* 732 total_entries 000252 automatic fixed bin(17,0) dcl 60 set ref 481* 514* 514 537* 537 542 565 total_intervals 000356 automatic fixed bin(17,0) dcl 88 set ref 628* 637 638 745 898 total_samples 000300 automatic fixed bin(35,0) dcl 75 set ref 549* 550 565 total_segs 2 based fixed bin(17,0) level 2 dcl 161 set ref 406* value 000742 automatic fixed bin(17,0) dcl 868 set ref 872* 875 876 876 valuex 000364 automatic fixed bin(17,0) dcl 93 set ref 650* 684* 684 875 878* 878 version based fixed bin(17,0) level 2 dcl 3-7 set ref 364* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. FNP_IDLE_DATA_VERSION_1 internal static fixed bin(17,0) initial dcl 1-32 get_system_free_area_ 000000 constant entry external dcl 181 max_fnp_idle_entries automatic fixed bin(17,0) dcl 1-29 star_ALL_ENTRIES internal static fixed bin(2,0) initial dcl 2-111 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 2-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 2-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 2-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-112 star_SEGMENT internal static fixed bin(2,0) initial unsigned dcl 2-120 star_branch_count automatic fixed bin(17,0) dcl 2-13 star_dir_list_branch based structure array level 1 dcl 2-59 star_link_count automatic fixed bin(17,0) dcl 2-17 star_link_pathname based char unaligned dcl 2-102 star_links based structure array level 1 dcl 2-76 star_linkx automatic fixed bin(17,0) dcl 2-18 star_list_branch based structure array level 1 dcl 2-41 star_list_branch_ptr automatic pointer dcl 2-16 star_list_names based char(32) array unaligned dcl 2-92 star_list_names_ptr automatic pointer dcl 2-20 star_select_sw automatic fixed bin(3,0) dcl 2-21 NAMES DECLARED BY EXPLICIT CONTEXT. ALL_DONE 004546 constant label dcl 798 ref 634 BOTH 001055 constant label dcl 277 ref 269 EXIT 004552 constant label dcl 800 ref 815 828 846 853 NEXT_SEG 002464 constant label dcl 454 ref 427 438 NO_DATA 003310 constant label dcl 586 ref 393 457 542 NO_DIR 001322 constant label dcl 311 ref 316 NO_NUMERIC_ARG 004604 constant label dcl 813 ref 821 SCAN_NEXT_SEG 004034 constant label dcl 714 ref 656 659 663 clean_up_everything 005171 constant entry internal dcl 883 ref 380 798 display_fnp_idle 000473 constant entry external dcl 12 free_segs 005334 constant entry internal dcl 916 ref 590 893 get_numeric_arg 004553 constant entry internal dcl 803 ref 291 296 get_time 004746 constant entry internal dcl 834 ref 285 288 store_value 005120 constant entry internal dcl 860 ref 671 677 699 NAMES DECLARED BY CONTEXT OR IMPLICATION. min builtin function ref 694 730 mod builtin function ref 731 string builtin function ref 365 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 5764 6056 5434 5774 Length 6372 5434 72 277 327 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME display_fnp_idle 747 external procedure is an external procedure. on unit on line 380 64 on unit get_numeric_arg internal procedure shares stack frame of external procedure display_fnp_idle. get_time internal procedure shares stack frame of external procedure display_fnp_idle. store_value internal procedure shares stack frame of external procedure display_fnp_idle. clean_up_everything 72 internal procedure is called by several nonquick procedures. free_segs 76 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME clean_up_everything 000100 infox clean_up_everything display_fnp_idle 000100 dirname display_fnp_idle 000152 hist display_fnp_idle 000153 summary display_fnp_idle 000154 from_time display_fnp_idle 000156 to_time display_fnp_idle 000160 minutes display_fnp_idle 000161 line_length display_fnp_idle 000162 code display_fnp_idle 000164 fnp_names display_fnp_idle 000166 fnps display_fnp_idle 000167 fnpx display_fnp_idle 000170 nargs display_fnp_idle 000171 iarg display_fnp_idle 000172 fnp_no display_fnp_idle 000174 areap display_fnp_idle 000176 earliest_of_all display_fnp_idle 000200 latest_of_all display_fnp_idle 000202 fnp_name display_fnp_idle 000203 i display_fnp_idle 000204 ok display_fnp_idle 000205 starname display_fnp_idle 000215 entryx display_fnp_idle 000216 earliest_found display_fnp_idle 000217 latest_found display_fnp_idle 000220 segx display_fnp_idle 000221 entname display_fnp_idle 000231 last_segx display_fnp_idle 000232 last_start display_fnp_idle 000234 last_finish display_fnp_idle 000236 last_entry display_fnp_idle 000240 last_time_in_seg display_fnp_idle 000242 last_entry_in_seg display_fnp_idle 000244 opening_time display_fnp_idle 000246 closing_time display_fnp_idle 000250 time_to_stop display_fnp_idle 000252 total_entries display_fnp_idle 000253 beginning_found display_fnp_idle 000254 prev_fnp_idle_datap display_fnp_idle 000256 first_segx display_fnp_idle 000257 first_entry display_fnp_idle 000260 first_idle_count display_fnp_idle 000261 first_sample_count display_fnp_idle 000262 last_idle_count display_fnp_idle 000263 last_sample_count display_fnp_idle 000264 latest_beginning display_fnp_idle 000266 min_sample display_fnp_idle 000270 minimum_time display_fnp_idle 000272 start_of_minimum_average display_fnp_idle 000274 min_idle display_fnp_idle 000276 min_idle_time display_fnp_idle 000300 total_samples display_fnp_idle 000301 absolute_max display_fnp_idle 000302 overall_average display_fnp_idle 000303 start_time_string display_fnp_idle 000311 end_time_string display_fnp_idle 000317 start_string display_fnp_idle 000323 end_string display_fnp_idle 000327 average_sample display_fnp_idle 000330 minimum_average display_fnp_idle 000331 min_start_string display_fnp_idle 000337 min_end_string display_fnp_idle 000345 min_idle_string display_fnp_idle 000354 hist_interval display_fnp_idle 000356 total_intervals display_fnp_idle 000357 no_of_fnps display_fnp_idle 000360 minimum_idle display_fnp_idle 000361 fnp_id display_fnp_idle 000362 next_time display_fnp_idle 000364 valuex display_fnp_idle 000365 residual display_fnp_idle 000366 entries_per_interval display_fnp_idle 000367 last_interval_start display_fnp_idle 000370 max_idle display_fnp_idle 000371 next_entryx display_fnp_idle 000372 latest_time display_fnp_idle 000374 last_origin display_fnp_idle 000376 end_of_last display_fnp_idle 000400 last_interval display_fnp_idle 000402 remaining_entries display_fnp_idle 000403 scale_marks display_fnp_idle 000404 top_of_scale display_fnp_idle 000405 hist_width display_fnp_idle 000406 cols_per_pct display_fnp_idle 000407 space display_fnp_idle 000410 ioa_str display_fnp_idle 000420 ioa_strl display_fnp_idle 000421 any display_fnp_idle 000422 prev_date display_fnp_idle 000424 cur_time display_fnp_idle 000426 suppressed display_fnp_idle 000436 line display_fnp_idle 000437 cells display_fnp_idle 000440 last_had_data display_fnp_idle 000441 output_line display_fnp_idle 000477 dt_string display_fnp_idle 000505 cur_column display_fnp_idle 000506 already display_fnp_idle 000507 new display_fnp_idle 000510 output display_fnp_idle 000530 fnp_info_array display_fnp_idle 000610 names_array_ptr display_fnp_idle 000612 seg_array_ptr display_fnp_idle 000614 seg_count display_fnp_idle 000616 idle_value_ptr display_fnp_idle 000620 infop display_fnp_idle 000622 argp display_fnp_idle 000624 argl display_fnp_idle 000626 auto_area_info display_fnp_idle 000660 fnp_idle_data_ptr display_fnp_idle 000662 star_entry_count display_fnp_idle 000664 star_entry_ptr display_fnp_idle 000666 star_names_ptr display_fnp_idle 000670 area_infop display_fnp_idle 000720 result get_numeric_arg 000730 time get_time 000740 delta_sample store_value 000741 max_possible store_value 000742 value store_value THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. fx1_to_fl2 alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out call_int_this call_int_other return fl2_to_fx1 mpfx2 mod_fx1 enable shorten_stack ext_entry int_entry divide_fx3 divide_fx4 alloc_based free_based empty THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ com_err_$suppress_name convert_date_to_binary_ cu_$arg_count cu_$arg_ptr cv_dec_check_ date_time_ define_area_ expand_pathname_ get_line_length_$switch get_wdir_ hcs_$initiate hcs_$star_ hcs_$terminate_noname ioa_ ioa_$rsnnl parse_fnp_name_ pathname_ release_area_ sort_items_$char THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$inconsistent error_table_$noarg error_table_$nomatch sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 12 000472 217 000500 218 000506 219 000510 220 000513 221 000514 222 000515 223 000527 224 000541 226 000542 227 000553 229 000555 230 000572 233 000573 235 000575 237 000622 240 000623 241 000631 242 000646 244 000650 245 000665 248 000666 250 000673 251 000713 253 000715 254 000751 257 000752 259 000756 260 001011 263 001012 264 001015 265 001016 266 001024 269 001025 272 001040 274 001043 277 001055 280 001101 283 001102 285 001105 288 001135 291 001161 294 001205 296 001215 297 001234 299 001237 301 001270 303 001271 305 001272 307 001302 308 001303 309 001320 311 001322 313 001346 316 001347 319 001354 320 001404 322 001406 323 001432 326 001433 327 001453 330 001454 331 001500 334 001501 336 001503 338 001507 339 001533 342 001534 345 001540 347 001564 350 001565 355 001620 358 001634 359 001636 360 001641 363 001645 364 001647 365 001651 366 001652 367 001655 368 001660 370 001662 371 001672 373 001674 374 001720 376 001721 377 001724 379 001727 380 001742 382 001764 383 001771 385 001775 386 002000 387 002005 388 002006 389 002010 390 002030 393 002074 396 002100 400 002123 401 002133 402 002141 403 002152 405 002154 406 002167 407 002172 408 002173 409 002204 410 002205 411 002207 412 002217 413 002223 415 002273 420 002353 421 002357 424 002363 425 002375 426 002402 427 002404 430 002405 432 002407 436 002415 437 002427 438 002434 441 002435 442 002440 443 002442 447 002450 448 002452 449 002454 450 002456 454 002464 457 002466 460 002470 461 002472 462 002502 464 002505 466 002507 467 002513 469 002517 470 002521 471 002523 474 002524 478 002535 481 002537 482 002541 483 002542 484 002545 485 002546 486 002553 487 002555 488 002557 489 002561 490 002563 492 002565 493 002567 495 002574 496 002577 497 002611 498 002614 501 002622 503 002624 504 002630 508 002641 509 002643 511 002645 514 002646 515 002650 518 002656 519 002660 522 002662 525 002670 526 002672 530 002674 533 002675 534 002677 537 002705 539 002707 541 002710 542 002711 545 002717 546 002725 547 002732 548 002734 549 002740 550 002746 551 002750 553 002764 554 003001 555 003016 556 003024 558 003036 560 003044 563 003077 565 003105 566 003113 569 003125 570 003142 571 003157 576 003221 578 003226 579 003243 584 003306 586 003310 590 003343 592 003353 595 003357 597 003363 598 003411 601 003413 603 003417 604 003421 607 003423 609 003427 610 003433 614 003435 616 003437 618 003441 620 003445 622 003447 624 003454 628 003461 629 003467 630 003470 631 003475 633 003502 634 003504 637 003506 638 003514 639 003540 640 003541 642 003543 643 003550 645 003554 646 003555 647 003561 648 003564 649 003566 650 003570 651 003572 653 003573 655 003605 656 003612 659 003616 662 003621 663 003626 666 003627 667 003631 668 003633 669 003635 671 003637 677 003665 678 003667 679 003672 682 003673 684 003677 686 003704 687 003706 688 003710 690 003711 693 003720 694 003724 696 003731 698 003754 699 003757 702 003774 703 003777 705 004002 707 004010 708 004012 709 004014 710 004021 711 004025 712 004030 714 004034 717 004036 721 004040 723 004042 724 004057 728 004063 729 004074 730 004076 731 004104 732 004111 734 004120 735 004123 736 004155 737 004201 738 004243 740 004263 741 004265 742 004267 743 004271 745 004301 746 004310 747 004311 748 004320 750 004331 751 004332 752 004345 754 004353 756 004355 760 004363 761 004376 764 004377 767 004400 768 004402 769 004403 770 004406 771 004423 773 004432 775 004437 776 004446 777 004452 780 004466 781 004477 782 004512 785 004521 786 004525 789 004526 791 004530 794 004541 795 004544 798 004546 800 004552 803 004553 809 004564 810 004565 811 004602 813 004604 815 004636 818 004637 820 004644 821 004647 824 004650 825 004675 827 004677 828 004741 831 004742 834 004746 841 004757 842 004760 843 004775 845 004777 846 005031 849 005032 850 005056 852 005060 853 005113 856 005114 860 005120 870 005122 871 005134 872 005136 875 005153 876 005163 878 005166 879 005167 883 005170 888 005176 889 005203 891 005210 892 005213 893 005215 896 005226 898 005230 901 005241 904 005275 907 005304 910 005315 911 005323 912 005332 916 005333 919 005341 920 005352 922 005373 923 005376 924 005403 925 005407 ----------------------------------------------------------- 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