COMPILATION LISTING OF SEGMENT fim_meters Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell LCPD Phoenix, System M Compiled on: 12/12/83 1622.6 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 /* format: style3 */ 10 11 fim_meters: 12 proc; 13 14 15 /* Program to print per-system count of faults by fault type, 16* which is accumulated in wired_hardcore_data by ring-0 fault 17* processing (fim, wired_fim, page_fault). 18* 19* Written January 1981 by J. Bongiovanni 20* Modified July 1981 by J. Bongiovanni for -reset fix 21* Modified October 1983 by R. Coppola for per-cpu fault counters 22**/ 23 24 /* Automatic */ 25 26 dcl CPU fixed bin; 27 dcl DISPLAY_SIZE fixed bin; 28 dcl INX fixed bin; 29 dcl argl fixed bin (21); 30 dcl argc fixed bin (21); /* character index into current arg */ 31 dcl argp ptr; 32 dcl ccp (1) ptr; 33 dcl code fixed bin (35); 34 dcl cpu bit (1); 35 dcl cpu_index fixed bin; 36 dcl cpu_string bit (8) aligned; 37 dcl 1 cur_per_cpu_ctrs (MAX_CPUS) aligned, 38 2 fault_counters (NO_TOTAL_FAULTS) fixed bin (35); 39 dcl 1 prev_per_cpu_ctrs (MAX_CPUS) aligned, 40 2 fault_counters (NO_TOTAL_FAULTS) fixed bin (35); 41 dcl cur_ptr (MAX_CPUS) ptr; 42 dcl default_to_all bit (1); 43 dcl display_cpu (9) fixed bin; 44 dcl got_cpu (MAX_CPUS + 1) bit (1); 45 dcl formatted_time (MAX_CPUS) char (10); 46 dcl found_name bit (1); 47 dcl i fixed bin; 48 dcl j fixed bin; 49 dcl k fixed bin; 50 dcl l fixed bin; 51 dcl 1 line unal, 52 2 title char (26), 53 2 field (8) char (13); 54 dcl line_length fixed bin (17); 55 dcl long bit (1); 56 dcl meter_time (MAX_CPUS) fixed bin (71); 57 dcl meters_printed fixed bin; 58 dcl nargs fixed bin; 59 dcl ncpus_selected fixed bin; 60 dcl ncpus_to_do fixed bin; 61 dcl order (32) fixed bin; 62 dcl pcp (1) ptr; 63 dcl pic13 picture "zzzzzzzzzzzz9"; 64 dcl prev_ptr (MAX_CPUS) ptr; 65 dcl print_fault (32) bit (1); 66 dcl report bit (1); 67 dcl reset bit (1); 68 dcl single_fault_index fixed bin; 69 dcl sort bit (1); 70 dcl sub_order (NO_TOTAL_FAULTS) fixed bin; 71 dcl temp_sw bit (1); 72 dcl total bit (1); 73 dcl total_sw bit (1); 74 dcl totals_only bit (1); 75 dcl total_flt_ctrs (NO_TOTAL_FAULTS) fixed bin (35); 76 77 78 79 80 /* Static */ 81 82 dcl unique (8) fixed bin int static init (0, 0, 0, 0, 0, 0, 0, 0); 83 84 dcl ALL_CPUS bit (8) int static options (constant) init ("11111111"b); 85 86 dcl CPU_TAGS char (16) int static options (constant) init ("ABCDEFGHabcdefgh"); 87 88 dcl my_name char (10) init ("fim_meters") int static options (constant); 89 dcl entry_names (8) char (19) int static options (constant) 90 init ("cpu_a_flt_ctr_array", "cpu_b_flt_ctr_array", "cpu_c_flt_ctr_array", 91 "cpu_d_flt_ctr_array", "cpu_e_flt_ctr_array", "cpu_f_flt_ctr_array", "cpu_g_flt_ctr_array", 92 "cpu_h_flt_ctr_array"); 93 94 95 /* Based */ 96 97 dcl arg char (argl) based (argp); 98 dcl cur_fault_count (NO_TOTAL_FAULTS) fixed bin (35) based (ccp (1)); 99 dcl prev_fault_count (NO_TOTAL_FAULTS) fixed bin (35) based (pcp (1)); 100 101 /* Entry */ 102 103 dcl com_err_ entry options (variable); 104 dcl cu_$arg_count entry (fixed bin); 105 dcl cu_$arg_ptr entry (fixed bin, ptr, fixed bin (21), fixed bin (35)); 106 dcl get_line_length_$switch 107 entry (ptr, fixed bin (35)) returns (fixed bin); 108 dcl ioa_ entry options (variable); 109 dcl ioa_$rsnnl entry () options (variable); 110 dcl metering_util_$define_regions 111 entry options (variable); 112 dcl metering_util_$fill_buffers 113 entry (fixed bin, fixed bin (71), char (*), (*) ptr, (*) ptr, fixed bin (35)); 114 dcl metering_util_$reset 115 entry (fixed bin, fixed bin (35)); 116 117 /* External */ 118 119 dcl error_table_$bad_arg 120 fixed bin (35) external; 121 dcl error_table_$badopt fixed bin (35) external; 122 dcl error_table_$inconsistent 123 fixed bin (35) external; 124 dcl error_table_$noarg fixed bin (35) external; 125 1 1 /* START OF: fim_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 1 2 1 3 /* Declarations useful for programs which interpret the per-cpu fault and cache 1 4* error counter data maintained in wired_hardcore_data$cpu_X_flt_ctr_array and 1 5* wired_hardcore_data$cpu_X_cache_err_ctr_array. The fault counters are an 1 6* array of counts by fault number, where the first NO_HARDWARE_FAULTS 1 7* fault numbers correspond to hardware faults, and the remaining 1 8* correspond to sub-cases of hardware faults, as defined procedurally in 1 9* fim. The per-cpu cache error counters are simply an array of error counters. 1 10* The cache error counter array is defined as: location ZERO contains the 1 11* cache size/type and is filled in by init_processor;location 1 thru 12 hold 1 12* the error counters as filled in by fim_util or page_fault. 1 13* 1 14* Written March 1981 by J. Bongiovanni */ 1 15 /* Modified July 1981 by M. Weaver for undefined_pointer 1 16* Modified October 1983 by Rich Coppola for support of per-processor fault and cache counters. 1 17**/ 1 18 1 19 dcl MAX_CPUS fixed bin init (8) int static options (constant); 1 20 /* current maximum of CPU numbers */ 1 21 1 22 dcl CPU_NAMES (8) char (1) int static options (constant) init ( 1 23 "A", "B", "C", "D", "E", "F", "G", "H"); 1 24 dcl (NO_HARDWARE_FAULTS init (32), NO_TOTAL_FAULTS init (128)) 1 25 fixed bin int static options (constant); 1 26 1 27 dcl EXTANT_FAULT (32) bit (1) unaligned init ((26) (1)"1"b, (5) (1)"0"b, "1"b) 1 28 int static options (constant); /* by hardware fault no. "1"=> valid */ 1 29 1 30 dcl LONG_FAULT_NAME (128) char (30) init /* full names of faults */ 1 31 /* begin of hardware faults */ 1 32 ("shutdown", "store", "mme1", "fault_tag_1", "timer_runout", 1 33 "command", "derail", "lockup", "connect", "parity", 1 34 "illegal_procedure", "op_not_complete", "startup", 1 35 "overflow", "divide_check", "execute", "segment_fault", 1 36 "page_fault", "directed_fault_2", "directed_fault_3", 1 37 "access_violation", "mme2", "mme3", "mme4", "linkage_fault", 1 38 "fault_tag_3", (5) (1)"", "trouble", 1 39 /* begin of subordinate faults */ 1 40 "illegal_opcode", "null_pointer", "illegal_modifier", "illegal_ring_order", 1 41 "not_in_execute_bracket", "no_execute_permission", "not_in_read_bracket", 1 42 "no_read_permission", "not_in_write_bracket", "no_write_permission", 1 43 "not_a_gate", "not_in_call_bracket", "outward_call", "bad_outward_call", 1 44 "inward_return", "cross_ring_transfer", "ring_alarm_fault", "am_fault", 1 45 "out_of_bounds", "fixedoverflow", "overflow", "underflow", "stringsize", 1 46 "illegal_procedure", "stack_out_of_bounds", "packed_pointer_fault", 1 47 "lot_fault", "isot_fault", "system_packed_pointer", (4) (1)" ", 1 48 "size", "neti", "command", "sus_", "trm_", "wkp_", "undefined_pointer", (56) (1)" ") 1 49 1 50 int static options (constant); 1 51 1 52 dcl SHORT_FAULT_NAME (32) char (3) init /* short names of hardware faults */ 1 53 ("sdf", "str", "mme", "ft1", "tro", "cmd", "drl", "luf", 1 54 "con", "par", "ipr", "onc", "suf", "ovf", "div", "exf", 1 55 "df0", "df1", "df2", "df3", "acv", (3) (1)" ", "ft2", 1 56 "ft3", (5) (1)" ", "trb") int static options (constant); 1 57 1 58 1 59 /* The following table is used to thread subordinate (non-hardware known) 1 60* faults to primary (hardware known) fault types. Its existence and 1 61* contents depends on the way fim handles faults, and it corresponds 1 62* roughly to fault_table in fim. This table is an array of threads by 1 63* fault number. To follow a thread for a hardware fault, use the 1 64* value of this table indexed by hardware fault number to find the 1 65* first subordinate fault number (0=>none). Continue for the subordinate 1 66* fault until a thread of 0 is encountered. */ 1 67 1 68 dcl THREAD_FAULT (128) fixed bin int static options (constant) init ( 1 69 0, 0, 0, 0, 0, 58, 0, 0, 0, 0, 1 70 33, 0, 0, 52, 0, 0, 0, 0, 0, 0, 1 71 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 72 0, 0, 35, 36, 56, 37, 38, 39, 40, 41, 1 73 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 1 74 57, 53, 54, 55, 66, 0, 72, 59, 60, 61, 1 75 68, (67) 0); 1 76 1 77 1 78 dcl CACHE_TYPES (0:5) char (9) int static options (constant) init ( 1 79 "L68_NONE", " L68_2K", " DPS8_8K", " VSSC_8K", "VSSC_16K", "VSSC_32K"); 1 80 1 81 1 82 /* The cache size is placed in the first word of the per-processor array 1 83*by init_processor. The following declarations list the currently known sizes 1 84*and their decodes */ 1 85 1 86 dcl L68_NONE fixed bin int static options (constant) init (0), 1 87 L68_2K fixed bin int static options (constant) init (1), 1 88 DPS8_8K fixed bin int static options (constant) init (2), 1 89 VSSC_8K fixed bin int static options (constant) init (3), 1 90 VSSC_16K fixed bin int static options (constant) init (4), 1 91 VSSC_32K fixed bin int static options (constant) init (5); 1 92 1 93 dcl NO_CACHE_ERR_TYPES fixed bin int static options (constant) init (12); 1 94 1 95 1 96 /* Note PFR = Primary Fault Reg (L68/DPS8), EFR = Extended Fault Reg (DPS8) */ 1 97 1 98 dcl CACHE_ERROR_NAME (12) char (32) var int static options (constant) init ( 1 99 "Primary Dir Parity/MultiMatch", /* Cell 1; PFR Bit 32 */ 1 100 "PT A Buffer OVFL/PAR/SEQ Err", /* Cell 2; EFR Bit 36 */ 1 101 "PT B Buffer OVFL/PAR/SEQ Err", /* Cell 3; EFR Bit 37 */ 1 102 "PT C Buffer OVFL/PAR/SEQ Err", /* Cell 4; EFR Bit 38 */ 1 103 "PT D Buffer OVFL/PAR/SEQ Err", /* Cell 5; EFR Bit 39 */ 1 104 "Primary DIR/PT Buffer OVFL", /* Cell 6; EFR Bit 40 */ 1 105 "WNO Parity ANY Port", /* Cell 7; EFR Bit 41 for DPS8 (cache type = 2) ONLY */ 1 106 /* NOTE: This counter is NOT USED by the VS&SC Cache, 1 107* ONLY the 8k model CPU */ 1 108 "Level 0 Dup Dir Parity", /* Cell 8; EFR Bit 42 */ 1 109 "Level 1 Dup Dir Parity", /* Cell 9; EFR Bit 43 */ 1 110 "Level 2 Dup Dir Parity", /* Cell 10; EFR Bit 44 */ 1 111 "Level 3 Dup Dir Parity", /* Cell 10; EFR Bit 45 */ 1 112 "Dup Dir MultiMatch"); 1 113 /* Cell 11; EFR Bit 46 */ 1 114 1 115 1 116 /* END OF: fim_meters.incl.pl1 * * * * * * * * * * * * * * * * */ 127 128 129 /* Pick up and validate each argument */ 130 131 132 ncpus_selected, single_fault_index = 0; 133 totals_only, total_sw = "1"b; /* default */ 134 cpu_string, cpu, default_to_all, long, report, reset, sort, total, got_cpu (*) = "0"b; 135 call cu_$arg_count (nargs); 136 do i = 1 to nargs; 137 call cu_$arg_ptr (i, argp, argl, code); 138 if substr (arg, 1, 1) ^= "-" & i = 1 & nargs = 1 139 then do; /* arg is fault name */ 140 do j = 1 to NO_HARDWARE_FAULTS while (single_fault_index = 0); 141 /* look for name in tables */ 142 if arg = LONG_FAULT_NAME (j) | arg = SHORT_FAULT_NAME (j) 143 then single_fault_index = j; 144 end; 145 if single_fault_index = 0 146 then do j = NO_HARDWARE_FAULTS + 1 to NO_TOTAL_FAULTS while (single_fault_index = 0); 147 if arg = LONG_FAULT_NAME (j) 148 then single_fault_index = j; 149 end; 150 if single_fault_index = 0 151 then do; /* invalid fault name */ 152 call com_err_ (error_table_$bad_arg, my_name, "Invalid fault name. ^a", arg); 153 return; 154 end; 155 end; 156 else if arg = "-report" 157 then report = "1"b; 158 else if arg = "-reset" | arg = "-rs" 159 then reset = "1"b; 160 else if arg = "-report_reset" | arg = "-rr" 161 then do; 162 report = "1"b; 163 reset = "1"b; 164 end; 165 else if arg = "-long" | arg = "-lg" 166 then long = "1"b; 167 168 else if arg = "-tt" | arg = "total" 169 then total = "1"b; 170 171 else if arg = "-sort" 172 then do; 173 sort = "1"b; /* sort by count is default */ 174 call cu_$arg_ptr (i + 1, argp, argl, code); 175 /* check for sort string */ 176 if code = 0 177 then /* argument exists */ 178 if substr (arg, 1, 1) ^= "-" 179 then do; /* not control argument */ 180 if arg = "number" 181 then sort = "0"b; /* sort by fault number (no sort, really) */ 182 else if arg = "count" 183 then sort = "1"b; /* sort by count of faults */ 184 else do; /* invalid sort string */ 185 call com_err_ (error_table_$bad_arg, my_name, "Invalid sort string. ^a", 186 arg); 187 return; 188 end; 189 i = i + 1; /* adjust argument number */ 190 end; 191 end; 192 193 else if arg = "-cpu" 194 then do; 195 cpu = "1"b; 196 totals_only = "0"b; 197 if i = nargs 198 then default_to_all = "1"b; 199 else do; 200 call cu_$arg_ptr (i + 1, argp, argl, code); 201 if char (arg, 1) = "-" 202 then default_to_all = "1"b; 203 end; 204 205 if default_to_all 206 then do; /* No cpu_list, defaults to all cpus */ 207 substr (cpu_string, 1, MAX_CPUS) = ALL_CPUS; 208 ncpus_selected = MAX_CPUS; 209 end; 210 211 else do; /* cpus specified by tag */ 212 i = i + 1; /* update index */ 213 if argl > 8 214 then do; 215 call com_err_ (0, my_name, "Too many CPUs specified (^a).", arg); 216 return; 217 end; 218 219 if verify (arg, CPU_TAGS) ^= 0 220 then do; 221 call com_err_ (0, my_name, "Invalid CPU Tag(s) ^a", arg); 222 return; 223 end; 224 do argc = 1 to argl; 225 substr (cpu_string, mod (index (CPU_TAGS, substr (arg, argc, 1)) - 1, 8) + 1, 1) = 226 "1"b; 227 ncpus_selected = ncpus_selected + 1; 228 end; 229 end; 230 end; 231 232 233 else do; 234 call com_err_ (error_table_$badopt, my_name, arg); 235 return; 236 end; 237 end; 238 239 240 if cpu & sort 241 then do; 242 call com_err_ (error_table_$inconsistent, my_name, "Incompatible args selected, -cpu & -sort."); 243 return; 244 end; 245 246 if ^report & ^reset 247 then report = "1"b; /* default is -report */ 248 249 /* Initialize if this is the first call */ 250 251 do i = 1 to MAX_CPUS; 252 if unique (i) = 0 253 then do; 254 call metering_util_$define_regions (unique (i), code, "wired_hardcore_data", entry_names (i), 255 NO_TOTAL_FAULTS); 256 if code ^= 0 257 then call com_err_ (code, my_name, "Initializing"); 258 end; 259 end; 260 261 262 /* Set flags to print all existent faults */ 263 264 do i = 1 to NO_HARDWARE_FAULTS; 265 print_fault (i) = EXTANT_FAULT (i); 266 end; 267 268 total_flt_ctrs (*) = 0; 269 do i = 1 to MAX_CPUS; 270 call metering_util_$fill_buffers (unique (i), meter_time (i), formatted_time (i), ccp, pcp, code) 271 ; 272 if code ^= 0 273 then do; 274 call com_err_ (code, my_name, "Filling buffers"); 275 return; 276 end; 277 cur_ptr (i) = ccp (1); 278 prev_ptr (i) = pcp (1); 279 cur_per_cpu_ctrs (i).fault_counters (*) = cur_fault_count (*); 280 prev_per_cpu_ctrs (i).fault_counters (*) = prev_fault_count (*); 281 if substr (cpu_string, i, 1) 282 then got_cpu (i) = "1"b; /* for printing purposes */ 283 if sum (cur_fault_count (*)) - sum (prev_fault_count (*)) = 0 284 then got_cpu (i) = "0"b; /* this cpu has never been on-line */ 285 286 287 do INX = 1 to NO_TOTAL_FAULTS; /* keep track of total faults */ 288 total_flt_ctrs (INX) = 289 total_flt_ctrs (INX) 290 + (cur_per_cpu_ctrs (i).fault_counters (INX) 291 - prev_per_cpu_ctrs (i).fault_counters (INX)); 292 end; 293 294 end; 295 296 /* Now have all totals per cpu and for all cpus, time to print everything */ 297 298 if report 299 then do; 300 301 line_length = get_line_length_$switch (null (), code); 302 if line_length < 132 303 then DISPLAY_SIZE = 4; 304 else DISPLAY_SIZE = 8; 305 if code ^= 0 306 then DISPLAY_SIZE = 8; 307 308 309 call ioa_ ("^/Total Metering Time:^-^a", formatted_time (1)); 310 if totals_only 311 then do; 312 call print_totals_only (); 313 end; 314 else do; 315 display_cpu (*) = 0; 316 cpu_index = 1; 317 call get_cpus_to_display (); 318 if ncpus_selected > DISPLAY_SIZE 319 then do; 320 call print_cpu_meters ("0"b); 321 display_cpu (*) = 0; 322 call get_cpus_to_display (); 323 end; 324 call print_cpu_meters (total); 325 end; 326 end; 327 328 if reset then do; 329 do i = 1 to MAX_CPUS; 330 call metering_util_$reset (unique (i), code); 331 if code ^= 0 332 then call com_err_ (code, my_name, "Resetting"); 333 end; 334 total_flt_ctrs (*) = 0; 335 end; 336 call ioa_ ("^/"); 337 338 /* Internal procedure to sort an array of indices by count of faults */ 339 340 bubble_sort: 341 proc (N, array); 342 343 dcl array (*) fixed bin; /* array of indices */ 344 dcl N fixed bin; 345 346 dcl i fixed bin; 347 dcl j fixed bin; 348 dcl k fixed bin; 349 350 351 do i = 1 to N - 1; 352 do j = i + 1 to N; 353 if total_flt_ctrs (array (i)) < total_flt_ctrs (array (j)) 354 then do; 355 k = array (i); 356 array (i) = array (j); 357 array (j) = k; 358 end; 359 end; 360 end; 361 362 end bubble_sort; 363 364 /* Internal procedure */ 365 get_cpus_to_display: 366 proc (); 367 368 dcl (i, j) fixed bin; 369 370 j = 0; 371 do i = cpu_index to MAX_CPUS while (j < DISPLAY_SIZE); 372 if got_cpu (i) 373 then do; 374 j = j + 1; 375 display_cpu (j) = i; 376 end; 377 end; 378 cpu_index = i; /* set up for next call */ 379 380 end get_cpus_to_display; 381 382 /* Internal procedure to print meters */ 383 384 print_hw_fault: 385 proc (sub_order_sw, ifault, totals_too); 386 387 dcl (icpu, ifault, j) fixed bin; 388 dcl totals_too bit (1); 389 dcl output char (132) var; 390 dcl (ignore, k) fixed bin; 391 dcl sub_order_sw bit (1); 392 dcl totals_position fixed bin; 393 dcl first_zero bit (1); 394 dcl non_zero bit (1); 395 396 non_zero = "0"b; 397 output = ""; 398 totals_position = DISPLAY_SIZE; 399 first_zero = "1"b; 400 401 do j = 1 to DISPLAY_SIZE while (non_zero = "0"b); 402 if display_cpu (j) > 0 403 then do; 404 if ^sub_order_sw 405 then do; 406 if (cur_per_cpu_ctrs (display_cpu (j)).fault_counters (ifault) 407 - prev_per_cpu_ctrs (display_cpu (j)).fault_counters (ifault)) ^= 0 408 then non_zero = "1"b; 409 end; 410 else do; 411 if cur_per_cpu_ctrs (display_cpu (j)).fault_counters (sub_order (ifault)) 412 - prev_per_cpu_ctrs (display_cpu (j)).fault_counters (sub_order (ifault)) ^= 0 413 then non_zero = "1"b; 414 end; 415 416 end; 417 end; 418 if ^non_zero 419 then return; /* dont display all zero lines */ 420 421 string (line) = ""; /* clear the display line */ 422 if ^sub_order_sw 423 then call ioa_$rsnnl ("^30a", output, ignore, LONG_FAULT_NAME (ifault)); 424 else call ioa_$rsnnl ("^3t^30a", output, ignore, LONG_FAULT_NAME (sub_order (ifault))); 425 line.title = rtrim (output); 426 427 k = 0; 428 do j = 1 to DISPLAY_SIZE; 429 if display_cpu (j) > 0 430 then do; 431 k = k + 1; 432 if ^sub_order_sw 433 then do; 434 pic13 = cur_per_cpu_ctrs (display_cpu (j)).fault_counters (ifault) 435 - prev_per_cpu_ctrs (display_cpu (j)).fault_counters (ifault); 436 line.field (k) = pic13; 437 end; 438 439 else do; 440 pic13 = cur_per_cpu_ctrs (display_cpu (j)).fault_counters (sub_order (ifault)) 441 - prev_per_cpu_ctrs (display_cpu (j)).fault_counters (sub_order (ifault)); 442 line.field (k) = pic13; 443 end; 444 end; 445 else do; 446 if first_zero 447 then do; 448 totals_position = j; 449 first_zero = "0"b; 450 end; 451 end; 452 end; 453 454 if totals_too 455 then do; 456 k = k + 1; 457 if ^sub_order_sw 458 then do; 459 pic13 = total_flt_ctrs (ifault); 460 line.field (k) = pic13; 461 end; 462 else do; 463 pic13 = total_flt_ctrs (sub_order (ifault)); 464 line.field (k) = pic13; 465 end; 466 end; 467 468 call ioa_ ("^a", string (line)); 469 470 end print_hw_fault; 471 472 /* Internal procedure to print meters */ 473 474 print_cpu_meters: 475 proc (totals_too); 476 477 dcl totals_too bit (1) parameter; 478 dcl (i, j, k, l) fixed bin; 479 dcl ignore fixed bin; 480 481 482 string (line) = ""; 483 line.title = "Fault Type"; 484 k = 0; 485 do j = 1 to DISPLAY_SIZE; 486 if display_cpu (j) > 0 487 then do; 488 k = k + 1; 489 line.field (k) = " CPU " || CPU_NAMES (display_cpu (j)); 490 end; 491 end; 492 493 if totals_too 494 then do; 495 k = k + 1; 496 line.field (k) = " TOTALS"; 497 end; 498 call ioa_ ("^/^a", string (line)); 499 500 501 do i = 1 to NO_HARDWARE_FAULTS; 502 503 if LONG_FAULT_NAME (i) = "" 504 then goto SKIP_IT; 505 call print_hw_fault ("0"b, i, totals_too); 506 if long 507 then do; /* print subordinate fault info */ 508 k = 0; 509 j = i; 510 do while (THREAD_FAULT (j) ^= 0); 511 k = k + 1; 512 sub_order (k) = THREAD_FAULT (j); 513 j = THREAD_FAULT (j); 514 end; 515 516 if k > 0 517 then do; 518 do l = 1 to k; 519 call print_hw_fault ("1"b, l, totals_too); 520 end; 521 end; 522 end; 523 SKIP_IT: 524 end; 525 526 527 end print_cpu_meters; 528 529 /* Internal procedure to print total meters */ 530 531 print_totals_only: 532 proc (); 533 534 call ioa_ ("^/Fault Type^29tTotal Fault Count"); 535 536 if single_fault_index = 0 537 then do; 538 do i = 1 to NO_HARDWARE_FAULTS; 539 order (i) = i; 540 if total_flt_ctrs (i) = 0 541 then print_fault (i) = "0"b; /* eliminate zeroes */ 542 end; 543 if sort 544 then call bubble_sort (NO_HARDWARE_FAULTS, order); 545 /* sort by count of faults */ 546 547 do i = 1 to NO_HARDWARE_FAULTS; 548 if print_fault (order (i)) 549 then do; 550 call ioa_ ("^30a^33t^13d", LONG_FAULT_NAME (order (i)), total_flt_ctrs (order (i))); 551 552 if long 553 then do; /* print subordinate fault info */ 554 k = 0; 555 j = order (i); 556 557 do while (THREAD_FAULT (j) ^= 0); 558 if total_flt_ctrs (THREAD_FAULT (j)) ^= 0 559 then temp_sw = "1"b; 560 561 if ^sort | temp_sw 562 then do; 563 k = k + 1; 564 sub_order (k) = THREAD_FAULT (j); 565 end; 566 j = THREAD_FAULT (j); 567 end; 568 if k > 0 569 then do; 570 if sort 571 then call bubble_sort (k, sub_order); 572 do l = 1 to k; 573 if total_flt_ctrs (sub_order (l)) ^= 0 574 then call ioa_ ("^3x^30a^33t^13d", 575 LONG_FAULT_NAME (sub_order (l)), 576 total_flt_ctrs (sub_order (l))); 577 end; 578 end; 579 end; 580 end; 581 end; 582 end; 583 584 else call ioa_ ("^30a^33t^13d", LONG_FAULT_NAME (single_fault_index), total_flt_ctrs (single_fault_index)); 585 586 end print_totals_only; 587 588 589 590 end fim_meters; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 12/12/83 1559.5 fim_meters.pl1 >spec>on>12/12/83>fim_meters.pl1 126 1 10/28/83 1424.1 fim_meters.incl.pl1 >ldd>include>fim_meters.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ALL_CPUS 006036 constant bit(8) initial unaligned dcl 84 ref 207 CPU_NAMES 002134 constant char(1) initial array unaligned dcl 1-22 ref 489 CPU_TAGS 002207 constant char(16) initial unaligned dcl 86 ref 219 225 DISPLAY_SIZE 000100 automatic fixed bin(17,0) dcl 27 set ref 302* 304* 305* 318 371 398 401 428 485 EXTANT_FAULT 002130 constant bit(1) initial array unaligned dcl 1-27 ref 265 INX 000101 automatic fixed bin(17,0) dcl 28 set ref 287* 288 288 288 288* LONG_FAULT_NAME 000230 constant char(30) initial array unaligned dcl 1-30 set ref 142 147 422* 424* 503 550* 573* 584* MAX_CPUS constant fixed bin(17,0) initial dcl 1-19 ref 37 39 41 44 45 56 64 207 208 251 269 329 371 N parameter fixed bin(17,0) dcl 344 ref 340 351 352 NO_HARDWARE_FAULTS 002132 constant fixed bin(17,0) initial dcl 1-24 set ref 140 145 264 501 538 543* 547 NO_TOTAL_FAULTS 002131 constant fixed bin(17,0) initial dcl 1-24 set ref 37 39 70 75 145 254* 279 279 279 279 280 280 280 280 283 283 287 288 288 288 288 406 406 406 406 411 411 411 411 434 434 434 434 440 440 440 440 SHORT_FAULT_NAME 000200 constant char(3) initial array unaligned dcl 1-52 ref 142 THREAD_FAULT 000000 constant fixed bin(17,0) initial array dcl 1-68 ref 510 512 513 557 558 564 566 arg based char unaligned dcl 97 set ref 138 142 142 147 152* 156 158 158 160 160 165 165 168 168 171 176 180 182 185* 193 201 215* 219 221* 225 234* argc 000103 automatic fixed bin(21,0) dcl 30 set ref 224* 225* argl 000102 automatic fixed bin(21,0) dcl 29 set ref 137* 138 142 142 147 152 152 156 158 158 160 160 165 165 168 168 171 174* 176 180 182 185 185 193 200* 201 213 215 215 219 221 221 224 225 234 234 argp 000104 automatic pointer dcl 31 set ref 137* 138 142 142 147 152 156 158 158 160 160 165 165 168 168 171 174* 176 180 182 185 193 200* 201 215 219 221 225 234 array parameter fixed bin(17,0) array dcl 343 set ref 340 353 353 355 356* 356 357* ccp 000106 automatic pointer array dcl 32 set ref 270* 277 279 283 code 000110 automatic fixed bin(35,0) dcl 33 set ref 137* 174* 176 200* 254* 256 256* 270* 272 274* 301* 305 330* 331 331* com_err_ 000020 constant entry external dcl 103 ref 152 185 215 221 234 242 256 274 331 cpu 000111 automatic bit(1) unaligned dcl 34 set ref 134* 195* 240 cpu_index 000112 automatic fixed bin(17,0) dcl 35 set ref 316* 371 378* cpu_string 000113 automatic bit(8) dcl 36 set ref 134* 207* 225* 281 cu_$arg_count 000022 constant entry external dcl 104 ref 135 cu_$arg_ptr 000024 constant entry external dcl 105 ref 137 174 200 cur_fault_count based fixed bin(35,0) array dcl 98 ref 279 283 cur_per_cpu_ctrs 000114 automatic structure array level 1 dcl 37 cur_ptr 000114 automatic pointer array dcl 41 set ref 277* default_to_all 000114 automatic bit(1) unaligned dcl 42 set ref 134* 197* 201* 205 display_cpu 000115 automatic fixed bin(17,0) array dcl 43 set ref 315* 321* 375* 402 406 406 411 411 429 434 434 440 440 486 489 entry_names 002136 constant char(19) initial array unaligned dcl 89 set ref 254* error_table_$bad_arg 000042 external static fixed bin(35,0) dcl 119 set ref 152* 185* error_table_$badopt 000044 external static fixed bin(35,0) dcl 121 set ref 234* error_table_$inconsistent 000046 external static fixed bin(35,0) dcl 122 set ref 242* fault_counters 000114 automatic fixed bin(35,0) array level 2 in structure "prev_per_cpu_ctrs" dcl 39 in procedure "fim_meters" set ref 280* 288 406 411 434 440 fault_counters 000114 automatic fixed bin(35,0) array level 2 in structure "cur_per_cpu_ctrs" dcl 37 in procedure "fim_meters" set ref 279* 288 406 411 434 440 field 6(18) 000132 automatic char(13) array level 2 packed unaligned dcl 51 set ref 436* 442* 460* 464* 489* 496* first_zero 000454 automatic bit(1) unaligned dcl 393 set ref 399* 446 449* formatted_time 000126 automatic char(10) array unaligned dcl 45 set ref 270* 309* get_line_length_$switch 000026 constant entry external dcl 106 ref 301 got_cpu 000126 automatic bit(1) array unaligned dcl 44 set ref 134* 281* 283* 372 i 000126 automatic fixed bin(17,0) dcl 47 in procedure "fim_meters" set ref 136* 137* 138 174 189* 189 197 200 212* 212* 251* 252 254 254* 264* 265 265* 269* 270 270 270 277 278 279 280 281 281 283 288 288* 329* 330* 538* 539 539 540 540* 547* 548 550 550 555* i 000466 automatic fixed bin(17,0) dcl 478 in procedure "print_cpu_meters" set ref 501* 503 505* 509* i 000360 automatic fixed bin(17,0) dcl 346 in procedure "bubble_sort" set ref 351* 352 353 355 356* i 000374 automatic fixed bin(17,0) dcl 368 in procedure "get_cpus_to_display" set ref 371* 372 375* 378 ifault parameter fixed bin(17,0) dcl 387 ref 384 406 406 411 411 422 424 434 434 440 440 459 463 ignore 000451 automatic fixed bin(17,0) dcl 390 set ref 422* 424* ioa_ 000030 constant entry external dcl 108 ref 309 336 468 498 534 550 573 584 ioa_$rsnnl 000032 constant entry external dcl 109 ref 422 424 j 000127 automatic fixed bin(17,0) dcl 48 in procedure "fim_meters" set ref 140* 142 142 142* 145* 147 147* 555* 557 558 564 566* 566 j 000361 automatic fixed bin(17,0) dcl 347 in procedure "bubble_sort" set ref 352* 353 356 357* j 000406 automatic fixed bin(17,0) dcl 387 in procedure "print_hw_fault" set ref 401* 402 406 406 411 411* 428* 429 434 434 440 440 448* j 000467 automatic fixed bin(17,0) dcl 478 in procedure "print_cpu_meters" set ref 485* 486 489* 509* 510 512 513* 513 j 000375 automatic fixed bin(17,0) dcl 368 in procedure "get_cpus_to_display" set ref 370* 371 374* 374 375 k 000130 automatic fixed bin(17,0) dcl 49 in procedure "fim_meters" set ref 554* 563* 563 564 568 570* 572 k 000452 automatic fixed bin(17,0) dcl 390 in procedure "print_hw_fault" set ref 427* 431* 431 436 442 456* 456 460 464 k 000362 automatic fixed bin(17,0) dcl 348 in procedure "bubble_sort" set ref 355* 357 k 000470 automatic fixed bin(17,0) dcl 478 in procedure "print_cpu_meters" set ref 484* 488* 488 489 495* 495 496 508* 511* 511 512 516 518 l 000131 automatic fixed bin(17,0) dcl 50 in procedure "fim_meters" set ref 572* 573 573 573* l 000471 automatic fixed bin(17,0) dcl 478 in procedure "print_cpu_meters" set ref 518* 519* line 000132 automatic structure level 1 packed unaligned dcl 51 set ref 421* 468 468 482* 498 498 line_length 000173 automatic fixed bin(17,0) dcl 54 set ref 301* 302 long 000174 automatic bit(1) unaligned dcl 55 set ref 134* 165* 506 552 meter_time 000176 automatic fixed bin(71,0) array dcl 56 set ref 270* metering_util_$define_regions 000034 constant entry external dcl 110 ref 254 metering_util_$fill_buffers 000036 constant entry external dcl 112 ref 270 metering_util_$reset 000040 constant entry external dcl 114 ref 330 my_name 002204 constant char(10) initial unaligned dcl 88 set ref 152* 185* 215* 221* 234* 242* 256* 274* 331* nargs 000176 automatic fixed bin(17,0) dcl 58 set ref 135* 136 138 197 ncpus_selected 000177 automatic fixed bin(17,0) dcl 59 set ref 132* 208* 227* 227 318 non_zero 000455 automatic bit(1) unaligned dcl 394 set ref 396* 401 406* 411* 418 order 000200 automatic fixed bin(17,0) array dcl 61 set ref 539* 543* 548 550 550 555 output 000407 automatic varying char(132) dcl 389 set ref 397* 422* 424* 425 pcp 000240 automatic pointer array dcl 62 set ref 270* 278 280 283 pic13 000242 automatic picture(13) unaligned dcl 63 set ref 434* 436 440* 442 459* 460 463* 464 prev_fault_count based fixed bin(35,0) array dcl 99 ref 280 283 prev_per_cpu_ctrs 000114 automatic structure array level 1 dcl 39 prev_ptr 000246 automatic pointer array dcl 64 set ref 278* print_fault 000246 automatic bit(1) array unaligned dcl 65 set ref 265* 540* 548 report 000247 automatic bit(1) unaligned dcl 66 set ref 134* 156* 162* 246 246* 298 reset 000250 automatic bit(1) unaligned dcl 67 set ref 134* 158* 163* 246 328 single_fault_index 000251 automatic fixed bin(17,0) dcl 68 set ref 132* 140 142* 145 145 147* 150 536 584 584 sort 000252 automatic bit(1) unaligned dcl 69 set ref 134* 173* 180* 182* 240 543 561 570 sub_order 000253 automatic fixed bin(17,0) array dcl 70 set ref 411 411 424 440 440 463 512* 564* 570* 573 573 573 sub_order_sw parameter bit(1) unaligned dcl 391 ref 384 404 422 432 457 temp_sw 000253 automatic bit(1) unaligned dcl 71 set ref 558* 561 title 000132 automatic char(26) level 2 packed unaligned dcl 51 set ref 425* 483* total 000254 automatic bit(1) unaligned dcl 72 set ref 134* 168* 324* total_flt_ctrs 000257 automatic fixed bin(35,0) array dcl 75 set ref 268* 288* 288 334* 353 353 459 463 540 550* 558 573 573* 584* total_sw 000255 automatic bit(1) unaligned dcl 73 set ref 133* totals_only 000256 automatic bit(1) unaligned dcl 74 set ref 133* 196* 310 totals_position 000453 automatic fixed bin(17,0) dcl 392 set ref 398* 448* totals_too parameter bit(1) unaligned dcl 477 in procedure "print_cpu_meters" set ref 474 493 505* 519* totals_too parameter bit(1) unaligned dcl 388 in procedure "print_hw_fault" ref 384 454 unique 000010 internal static fixed bin(17,0) initial array dcl 82 set ref 252 254* 270* 330* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. CACHE_ERROR_NAME internal static varying char(32) initial array dcl 1-98 CACHE_TYPES internal static char(9) initial array unaligned dcl 1-78 CPU automatic fixed bin(17,0) dcl 26 DPS8_8K internal static fixed bin(17,0) initial dcl 1-86 L68_2K internal static fixed bin(17,0) initial dcl 1-86 L68_NONE internal static fixed bin(17,0) initial dcl 1-86 NO_CACHE_ERR_TYPES internal static fixed bin(17,0) initial dcl 1-93 VSSC_16K internal static fixed bin(17,0) initial dcl 1-86 VSSC_32K internal static fixed bin(17,0) initial dcl 1-86 VSSC_8K internal static fixed bin(17,0) initial dcl 1-86 error_table_$noarg external static fixed bin(35,0) dcl 124 found_name automatic bit(1) unaligned dcl 46 icpu automatic fixed bin(17,0) dcl 387 ignore automatic fixed bin(17,0) dcl 479 meters_printed automatic fixed bin(17,0) dcl 57 ncpus_to_do automatic fixed bin(17,0) dcl 60 NAMES DECLARED BY EXPLICIT CONTEXT. SKIP_IT 005310 constant label dcl 523 ref 503 bubble_sort 004341 constant entry internal dcl 340 ref 543 570 fim_meters 002451 constant entry external dcl 11 get_cpus_to_display 004432 constant entry internal dcl 365 ref 317 322 print_cpu_meters 005115 constant entry internal dcl 474 ref 320 324 print_hw_fault 004465 constant entry internal dcl 384 ref 505 519 print_totals_only 005313 constant entry internal dcl 531 ref 312 NAMES DECLARED BY CONTEXT OR IMPLICATION. char builtin function ref 201 index builtin function ref 225 mod builtin function ref 225 null builtin function ref 301 301 rtrim builtin function ref 425 string builtin function set ref 421 468 468 482* 498 498 substr builtin function set ref 138 176 207* 225* 225 281 sum builtin function ref 283 283 verify builtin function ref 219 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 6210 6260 6041 6220 Length 6504 6041 50 210 146 10 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fim_meters 558 external procedure is an external procedure. bubble_sort internal procedure shares stack frame of external procedure fim_meters. get_cpus_to_display internal procedure shares stack frame of external procedure fim_meters. print_hw_fault internal procedure shares stack frame of external procedure fim_meters. print_cpu_meters internal procedure shares stack frame of external procedure fim_meters. print_totals_only internal procedure shares stack frame of external procedure fim_meters. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 unique fim_meters STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME fim_meters 000100 DISPLAY_SIZE fim_meters 000101 INX fim_meters 000102 argl fim_meters 000103 argc fim_meters 000104 argp fim_meters 000106 ccp fim_meters 000110 code fim_meters 000111 cpu fim_meters 000112 cpu_index fim_meters 000113 cpu_string fim_meters 000114 cur_per_cpu_ctrs fim_meters 000114 cur_ptr fim_meters 000114 default_to_all fim_meters 000114 prev_per_cpu_ctrs fim_meters 000115 display_cpu fim_meters 000126 formatted_time fim_meters 000126 got_cpu fim_meters 000126 i fim_meters 000127 j fim_meters 000130 k fim_meters 000131 l fim_meters 000132 line fim_meters 000173 line_length fim_meters 000174 long fim_meters 000176 nargs fim_meters 000176 meter_time fim_meters 000177 ncpus_selected fim_meters 000200 order fim_meters 000240 pcp fim_meters 000242 pic13 fim_meters 000246 print_fault fim_meters 000246 prev_ptr fim_meters 000247 report fim_meters 000250 reset fim_meters 000251 single_fault_index fim_meters 000252 sort fim_meters 000253 temp_sw fim_meters 000253 sub_order fim_meters 000254 total fim_meters 000255 total_sw fim_meters 000256 totals_only fim_meters 000257 total_flt_ctrs fim_meters 000360 i bubble_sort 000361 j bubble_sort 000362 k bubble_sort 000374 i get_cpus_to_display 000375 j get_cpus_to_display 000406 j print_hw_fault 000407 output print_hw_fault 000451 ignore print_hw_fault 000452 k print_hw_fault 000453 totals_position print_hw_fault 000454 first_zero print_hw_fault 000455 non_zero print_hw_fault 000466 i print_cpu_meters 000467 j print_cpu_meters 000470 k print_cpu_meters 000471 l print_cpu_meters THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return alloc_auto_adj mod_fx1 ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_ptr get_line_length_$switch ioa_ ioa_$rsnnl 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 11 002450 37 002456 39 002463 41 002470 44 002476 45 002505 56 002515 64 002523 70 002531 75 002535 270 002541 550 002545 570 002547 132 002557 133 002561 134 002564 135 002607 136 002616 137 002625 138 002642 140 002655 142 002667 144 002710 145 002712 147 002725 149 002737 150 002741 152 002743 153 002776 155 002777 156 003000 158 003010 160 003023 162 003033 163 003035 164 003036 165 003037 168 003052 171 003065 173 003071 174 003073 176 003113 180 003122 182 003131 185 003136 187 003171 189 003172 191 003173 193 003174 195 003200 196 003202 197 003203 200 003210 201 003227 205 003242 207 003244 208 003250 209 003252 212 003253 213 003254 215 003257 216 003312 219 003313 221 003325 222 003361 224 003362 225 003371 227 003406 228 003407 230 003411 234 003412 235 003436 237 003437 240 003441 242 003445 243 003471 246 003472 251 003500 252 003507 254 003512 256 003554 259 003604 264 003606 265 003615 266 003620 268 003622 269 003633 270 003643 272 003712 274 003714 275 003741 277 003742 278 003746 279 003751 280 003772 281 004012 283 004023 287 004067 288 004077 292 004117 294 004121 298 004123 301 004125 302 004142 304 004150 305 004152 309 004156 310 004176 312 004200 313 004201 315 004202 316 004212 317 004214 318 004215 320 004220 321 004224 322 004234 324 004235 328 004237 329 004241 330 004251 331 004262 333 004311 334 004313 336 004325 590 004340 340 004341 351 004345 352 004357 353 004371 355 004417 356 004421 357 004423 359 004425 360 004427 362 004431 365 004432 370 004433 371 004434 372 004446 374 004454 375 004455 377 004460 378 004462 380 004464 384 004465 396 004467 397 004470 398 004471 399 004473 401 004475 402 004505 404 004507 406 004515 409 004533 411 004534 417 004554 418 004556 421 004561 422 004564 424 004626 425 004663 427 004700 428 004701 429 004711 431 004713 432 004714 434 004722 436 004745 437 004752 440 004753 442 005000 444 005005 446 005006 448 005010 449 005012 452 005013 454 005015 456 005023 457 005024 459 005031 460 005043 461 005050 463 005051 464 005065 468 005072 470 005114 474 005115 482 005117 483 005122 484 005125 485 005126 486 005135 488 005137 489 005140 491 005152 493 005154 495 005162 496 005163 498 005170 501 005212 503 005221 505 005226 506 005243 508 005245 509 005246 510 005250 511 005253 512 005254 513 005257 514 005260 516 005261 518 005263 519 005271 520 005306 523 005310 527 005312 531 005313 534 005314 536 005330 538 005332 539 005341 540 005342 542 005351 543 005353 547 005360 548 005367 550 005374 552 005427 554 005431 555 005432 557 005435 558 005441 561 005446 563 005452 564 005453 566 005457 567 005461 568 005462 570 005464 572 005502 573 005511 577 005550 581 005552 582 005554 584 005555 586 005610 ----------------------------------------------------------- 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