?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Operator Facility : VED DAS/DAST/MMS/MMST/MRRT/SAS/SAST Display' ??
MODULE ofm$memory_manager_stat_display;
?? RIGHT := 110 ??

{ PURPOSE:
{   Supports the following VED displays
{     DYNAMIC_AGING_STATISTICS, DAS
{     DYNAMIC_AGING_STATISTICS_TOTAL, DAST
{     MEMORY_MANAGER_STATATISTICS, MMS
{     MEMORY_MANAGER_STATATISTICS_TOTAL, MMST
{     MEMORY_RING_REQUEST_TRACE, MRRT
{     SHARED_AGING_STATATISTICS, SAS
{     SHARED_AGING_STATATISTICS_TOTAL, SAST
{
{ DESIGN:
{   Displays data out of mmv$aging_statistics

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc oss$task_private
*copyc oss$task_shared
*copyc clt$value
*copyc clt$display_control
*copyc jmt$system_supplied_name
*copyc mmt$aging_statistics
*copyc mmt$assign_contig_passes
*copyc mmt$write_page_to_disk_status
*copyc ost$cpu_idle_statistics
*copyc ost$page_table
*copyc ost$status
*copyc ost$string
?? POP ??
*copyc clp$close_display
*copyc clp$new_display_line
*copyc clp$put_display
*copyc dpp$clear_window
*copyc dpp$put_next_line
*copyc mmp$convert_aging_statistics
*copyc ofp$build_system_line
*copyc ofp$open_display
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc pmp$binary_to_ascii_fit
?? EJECT ??
*copyc mmv$aging_statistics
*copyc mmv$dynamic_aging_statistics
*copyc mmv$gpql
*copyc mmv$last_active_shared_queue
*copyc mmv$max_working_set_size
*copyc mmv$paging_statistics
*copyc mmv$pf_statistics
*copyc mmv$reassignable_page_frames
*copyc mmv$reserved_page_count
*copyc mmv$resident_job_target
*copyc osv$task_shared_heap

  TYPE
    t$write_page_statistics = array [mmt$write_page_to_disk_status] of integer;

  VAR
    mmv$aio_limit_count: [XREF] integer,
    mmv$assign_contig_reject: [XREF] integer,
    mmv$assign_contiguous_pass_cnt: [XREF] mmt$assign_contig_passes,
    mmv$jmtr_escaped_allocate: [XREF] integer,
    mmv$maxws_aio_count: [XREF] integer,
    mmv$refs_to_unrec_df_file_inhib: [XREF] integer,
    mmv$refs_to_unrec_df_file_term: [XREF] integer,
    mmv$ring1_request_trace: [XREF] array [0 .. 20] of integer,
    mmv$write_page_statistics: [XREF] array [mmt$write_page_to_disk_status] of integer;

?? NEWTITLE := 'P$DYNAMIC_AGING_STAT_DISPLAY', EJECT ??

  PROCEDURE p$dynamic_aging_stat_display
    (    title: string ( * <= 40);
         total_display: boolean;
         wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      v$queue_names: [STATIC, READ, oss$job_paged_literal] array
            [mmc$pq_shared_first .. mmc$pq_shared_last] of string (8) := [
{             } 'TskServ:',
{             } 'Execute:',
{             } 'Non-Exe:',
{             } 'Device :',
{             } 'F-Serv :',
{             } '  Other:',
{             } 'Site_01:',
{             } 'Site_02:',
{             } 'Site_03:',
{             } 'Site_04:',
{             } 'Site_05:',
{             } 'Site_06:',
{             } 'Site_07:',
{             } 'Site_08:',
{             } 'Site_09:',
{             } 'Site_10:',
{             } 'Site_11:',
{             } 'Site_12:',
{             } 'Site_13:',
{             } 'Site_14:',
{             } 'Site_15:',
{             } 'Site_16:',
{             } 'Site_17:',
{             } 'Site_18:',
{             } 'Site_19:',
{             } 'Site_20:',
{             } 'Site_21:',
{             } 'Site_22:',
{             } 'Site_23:',
{             } 'Site_24:',
{             } 'Site_25:'];

    CONST
      c$header_lines = 9;

    TYPE
      t$display_data = mmt$dynamic_aging_statistics;

    VAR
      v$previous_data_for_display: [STATIC, oss$task_shared] boolean := FALSE,
      v$previous_display_data_p: [STATIC, oss$task_shared] ^t$display_data := NIL,
      v$system_line_info: [STATIC, oss$task_shared] ^oft$system_line_info := NIL;


    VAR
      data: t$display_data,
      display_control: clt$display_control,
      i: integer,
      queue: mmt$page_frame_queue_id,
      str_p: ^array [0 .. * ] of string (80);

?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

{ PURPOSE:
{   This procedure provides clean-up processing when a task abort occurs.

    PROCEDURE p$abort_handler
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           save_area_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      IF wid = 0 THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? NEWTITLE := 'P$GET_DATA', EJECT ??

    PROCEDURE p$get_data
      (    prev_data_p: ^t$display_data;
       VAR previous_data_for_display: boolean;
       VAR data: t$display_data);

      VAR
        local_data: t$display_data,
        queue: mmt$page_frame_queue_id;

      local_data := mmv$dynamic_aging_statistics;

      IF (prev_data_p = NIL) OR (previous_data_for_display = FALSE) THEN
        data := local_data;

        IF prev_data_p <> NIL THEN
          prev_data_p^ := local_data;
          previous_data_for_display := TRUE;
        IFEND;
        RETURN; {----->
      IFEND;

      data.reset_count := local_data.reset_count - prev_data_p^.reset_count;
      data.emergency_disabled := local_data.emergency_disabled - prev_data_p^.emergency_disabled;
      data.free_now_exceeds_floor_count := local_data.free_now_exceeds_floor_count -
            prev_data_p^.free_now_exceeds_floor_count;
      data.free_soon_exceeds_floor_count := local_data.free_soon_exceeds_floor_count -
            prev_data_p^.free_soon_exceeds_floor_count;
      data.floor_exceeds_free_now_count := local_data.floor_exceeds_free_now_count -
            prev_data_p^.floor_exceeds_free_now_count;
      data.free_now_exceeds_max_count := local_data.free_now_exceeds_max_count -
            prev_data_p^.free_now_exceeds_max_count;
      data.min_exceeds_free_now_count := local_data.min_exceeds_free_now_count -
            prev_data_p^.min_exceeds_free_now_count;
      data.increment_count_exceeds_max_pos := local_data.increment_count_exceeds_max_pos -
            prev_data_p^.increment_count_exceeds_max_pos;
      data.increment_count_exceeds_max_neg := local_data.increment_count_exceeds_max_neg -
            prev_data_p^.increment_count_exceeds_max_neg;
      data.increment_count_pos := local_data.increment_count_pos - prev_data_p^.increment_count_pos;
      data.increment_count_neg := local_data.increment_count_neg - prev_data_p^.increment_count_neg;

      FOR queue := LOWERBOUND (data.queue) TO UPPERBOUND (data.queue) DO
        data.queue [queue].size_non_encrease_count := local_data.queue [queue].size_non_encrease_count -
              prev_data_p^.queue [queue].size_non_encrease_count;
        data.queue [queue].aic_mod_increment_total := local_data.queue [queue].aic_mod_increment_total -
              prev_data_p^.queue [queue].aic_mod_increment_total;
        data.queue [queue].aic_unmod_increment_total := local_data.queue [queue].aic_unmod_increment_total -
              prev_data_p^.queue [queue].aic_unmod_increment_total;
        data.queue [queue].min_increment_total := local_data.queue [queue].min_increment_total -
              prev_data_p^.queue [queue].min_increment_total;
        data.queue [queue].max_increment_total := local_data.queue [queue].max_increment_total -
              prev_data_p^.queue [queue].max_increment_total;
        data.queue [queue].aic_mod_decrement_total := local_data.queue [queue].aic_mod_decrement_total -
              prev_data_p^.queue [queue].aic_mod_decrement_total;
        data.queue [queue].aic_unmod_decrement_total := local_data.queue [queue].aic_unmod_decrement_total -
              prev_data_p^.queue [queue].aic_unmod_decrement_total;
        data.queue [queue].min_decrement_total := local_data.queue [queue].min_decrement_total -
              prev_data_p^.queue [queue].min_decrement_total;
        data.queue [queue].max_decrement_total := local_data.queue [queue].max_decrement_total -
              prev_data_p^.queue [queue].max_decrement_total;
      FOREND;

      prev_data_p^ := local_data;

    PROCEND p$get_data;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;

    IF wid = 0 THEN
      osp$establish_block_exit_hndlr (^p$abort_handler);
    IFEND;
    IF initial_call THEN
      ofp$open_display (file_name, wid, dpc$wc_sharing, dpc$wk_table, title, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

{ Establish base values for the statistics display if they do not already exist.
    IF v$system_line_info = NIL THEN
      ALLOCATE v$system_line_info IN osv$task_shared_heap^;
      v$system_line_info^.initialized := FALSE;
    IFEND;

    IF (total_display = FALSE) AND (v$previous_display_data_p = NIL) THEN
      ALLOCATE v$previous_display_data_p IN osv$task_shared_heap^;
    IFEND;

    PUSH str_p: [0 .. c$header_lines + (mmv$last_active_shared_queue - mmc$pq_shared_first + 1)];

    ofp$build_system_line (v$system_line_info^, str_p^ [0]);
    IF total_display THEN
      p$get_data (NIL, v$previous_data_for_display, data);
    ELSE
      p$get_data (v$previous_display_data_p, v$previous_data_for_display, data);
    IFEND;

{Setup Lables
    str_p^ [01] := 'Pgs Given:            Given Pgs > MaxGiven:            Pgs > MaxFloor:';
    str_p^ [02] := 'Pgs Taken:            Taken Pgs > MaxTaken:            Pgs < MinFloor:';
    str_p^ [03] := 'No Candid:            Emergency Min Occ   :            Reset Count   :';
    str_p^ [04] := '';
    str_p^ [05] := 'Pgs To Give:            Reassignable Now :          Free :         Mod  :';
    str_p^ [06] := 'Pgs To Take:            Reassignable Soon:          Avail:         Wired:';
    str_p^ [07] := '';
    str_p^ [08] := '               QSize   AIC Mod    AIC Unmod   ------ Min ----- ------ Max ------';
    str_p^ [09] := 'SharedQ   Size bound Cur Inc Dec Cur Inc Dec   Cur   Inc   Dec   Cur   Inc   Dec ';

    pmp$binary_to_ascii_fit (data.free_now_exceeds_floor_count, 10, 9, 9, str_p^ [1] (12, 9));
    pmp$binary_to_ascii_fit (data.increment_count_exceeds_max_pos, 10, 9, 9, str_p^ [1] (45, 9));
    pmp$binary_to_ascii_fit (data.free_now_exceeds_max_count, 10, 9, 9, str_p^ [1] (72, 9));

    pmp$binary_to_ascii_fit (data.floor_exceeds_free_now_count, 10, 9, 9, str_p^ [2] (12, 9));
    pmp$binary_to_ascii_fit (data.increment_count_exceeds_max_neg, 10, 9, 9, str_p^ [2] (45, 9));
    pmp$binary_to_ascii_fit (data.min_exceeds_free_now_count, 10, 9, 9, str_p^ [2] (72, 9));

    pmp$binary_to_ascii_fit (data.free_soon_exceeds_floor_count, 10, 9, 9, str_p^ [3] (12, 9));
    pmp$binary_to_ascii_fit (data.emergency_disabled, 10, 9, 9, str_p^ [3] (45, 9));
    pmp$binary_to_ascii_fit (data.reset_count, 10, 9, 9, str_p^ [3] (72, 9));

    pmp$binary_to_ascii_fit (data.increment_count_pos, 10, 9, 9, str_p^ [5] (14, 9));
    pmp$binary_to_ascii_fit (mmv$reassignable_page_frames.now, 10, 6, 6, str_p^ [5] (44, 6));
    pmp$binary_to_ascii_fit (mmv$gpql [mmc$pq_free].pqle.count, 10, 6, 6, str_p^ [5] (60, 6));
    pmp$binary_to_ascii_fit (mmv$gpql [mmc$pq_avail_modified].pqle.count, 10, 6, 6, str_p^ [5] (75, 6));

    pmp$binary_to_ascii_fit (data.increment_count_neg, 10, 9, 9, str_p^ [6] (14, 9));
    pmp$binary_to_ascii_fit (mmv$reassignable_page_frames.soon, 10, 6, 6, str_p^ [6] (44, 6));
    pmp$binary_to_ascii_fit (mmv$gpql [mmc$pq_avail].pqle.count, 10, 6, 6, str_p^ [6] (60, 6));
    pmp$binary_to_ascii_fit (mmv$gpql [mmc$pq_wired].pqle.count, 10, 6, 6, str_p^ [6] (75, 6));

    i := c$header_lines + 1;
    FOR queue := mmc$pq_shared_first TO mmv$last_active_shared_queue DO
      str_p^ [i] := v$queue_names [queue];
      pmp$binary_to_ascii_fit (mmv$gpql [queue].pqle.count, 10, 5, 5, str_p^ [i] (10, 5));
      pmp$binary_to_ascii_fit (data.queue [queue].size_non_encrease_count, 10, 5, 5, str_p^ [i] (16, 5));
      pmp$binary_to_ascii_fit (mmv$gpql [queue].age_interval_actual_modified, 10, 3, 3, str_p^ [i] (22, 3));
      pmp$binary_to_ascii_fit (data.queue [queue].aic_mod_increment_total, 10, 3, 3, str_p^ [i] (26, 3));
      pmp$binary_to_ascii_fit (data.queue [queue].aic_mod_decrement_total, 10, 3, 3, str_p^ [i] (30, 3));
      pmp$binary_to_ascii_fit (mmv$gpql [queue].age_interval_actual_unmodified, 10, 3, 3, str_p^ [i] (34, 3));
      pmp$binary_to_ascii_fit (data.queue [queue].aic_unmod_increment_total, 10, 3, 3, str_p^ [i] (38, 3));
      pmp$binary_to_ascii_fit (data.queue [queue].aic_unmod_decrement_total, 10, 3, 3, str_p^ [i] (42, 3));
      pmp$binary_to_ascii_fit (mmv$gpql [queue].minimum_actual, 10, 5, 5, str_p^ [i] (46, 5));
      pmp$binary_to_ascii_fit (data.queue [queue].min_increment_total, 10, 5, 5, str_p^ [i] (52, 5));
      pmp$binary_to_ascii_fit (data.queue [queue].min_decrement_total, 10, 5, 5, str_p^ [i] (58, 5));
      pmp$binary_to_ascii_fit (mmv$gpql [queue].maximum_actual, 10, 5, 5, str_p^ [i] (64, 5));
      pmp$binary_to_ascii_fit (data.queue [queue].max_increment_total, 10, 5, 5, str_p^ [i] (70, 5));
      pmp$binary_to_ascii_fit (data.queue [queue].max_decrement_total, 10, 5, 5, str_p^ [i] (76, 5));
      i := i + 1;
    FOREND;

{ Display the results.
    IF wid <> 0 THEN
      dpp$clear_window (wid, status);
      FOR i := 0 TO UPPERBOUND (str_p^) DO
        dpp$put_next_line (wid, str_p^ [i], status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND
    ELSE
      FOR i := 0 TO UPPERBOUND (str_p^) DO
        clp$put_display (display_control, str_p^ [i], clc$trim, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
      clp$close_display (display_control, status);
      osp$disestablish_cond_handler;
    IFEND;

  PROCEND p$dynamic_aging_stat_display;
?? OLDTITLE ??
?? NEWTITLE := 'P$MEMORY_MANAGER_STAT_DISPLAY', EJECT ??

  PROCEDURE p$memory_manager_stat_display
    (    title: string ( * <= 40);
         total_display: boolean;
         wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    CONST
      max_lines = 27;

    TYPE
      t$display_data = record
        aging_statistics: mmt$aging_statistics,
        write_page_statistics: t$write_page_statistics,
        reassignable_page_frames: mmt$reassignable_page_frames,
        assign_contiguous_pass_cnt: mmt$assign_contig_passes,
        aio_limit_count: integer,
        assign_contig_reject: integer,
        jmtr_escaped_allocate: integer,
        max_working_set_size: integer,
        maxws_aio_count: integer,
        refs_to_unrec_df_file_inhib: integer,
        refs_to_unrec_df_file_term: integer,
        reserved_page_count: integer,
        resident_job_target: integer,
      recend;

    VAR
      v$previous_data_for_display: [STATIC, oss$task_shared] boolean := FALSE,
      v$previous_display_data_p: [STATIC, oss$task_shared] ^t$display_data := NIL,
      v$system_line_info: [STATIC, oss$task_shared] ^oft$system_line_info := NIL;

    VAR
      display_control: clt$display_control,
      disk_status: mmt$write_page_to_disk_status,
      data: t$display_data,
      i: integer,
      queue: mmt$page_frame_queue_id,
      str: array [0 .. max_lines] of string (80);

?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

{ PURPOSE:
{   This procedure provides clean-up processing when a task abort occurs.

    PROCEDURE p$abort_handler
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           save_area_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      IF wid = 0 THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? NEWTITLE := 'P$GET_DATA', EJECT ??

    PROCEDURE p$get_data
      (    prev_data_p: ^t$display_data;
       VAR previous_data_for_display: boolean;
       VAR data: t$display_data);

      VAR
        disk_status: mmt$write_page_to_disk_status,
        local_data: t$display_data,
        queue: mmt$page_frame_queue_id;

      mmp$convert_aging_statistics (mmv$aging_statistics, local_data.aging_statistics);
      local_data.write_page_statistics := mmv$write_page_statistics;
      local_data.aio_limit_count := mmv$aio_limit_count;
      local_data.assign_contig_reject := mmv$assign_contig_reject;
      local_data.assign_contiguous_pass_cnt := mmv$assign_contiguous_pass_cnt;
      local_data.jmtr_escaped_allocate := mmv$jmtr_escaped_allocate;
      local_data.max_working_set_size := mmv$max_working_set_size;
      local_data.maxws_aio_count := mmv$maxws_aio_count;
      local_data.reassignable_page_frames := mmv$reassignable_page_frames;
      local_data.refs_to_unrec_df_file_inhib := mmv$refs_to_unrec_df_file_inhib;
      local_data.refs_to_unrec_df_file_term := mmv$refs_to_unrec_df_file_term;
      local_data.reserved_page_count := mmv$reserved_page_count;
      local_data.resident_job_target := mmv$resident_job_target;

      IF (prev_data_p = NIL) OR (previous_data_for_display = FALSE) THEN
        data := local_data;

        IF prev_data_p <> NIL THEN
          prev_data_p^ := local_data;
          previous_data_for_display := TRUE;
        IFEND;
        RETURN; {----->
      IFEND;

      data.aging_statistics.force_aggressive_aging := local_data.aging_statistics.force_aggressive_aging -
            prev_data_p^.aging_statistics.force_aggressive_aging;
      data.aging_statistics.aggressive_age_shared_queue :=
            local_data.aging_statistics.aggressive_age_shared_queue -
            prev_data_p^.aging_statistics.aggressive_age_shared_queue;
      data.aging_statistics.aggressive_age_job_queues := local_data.aging_statistics.
            aggressive_age_job_queues - prev_data_p^.aging_statistics.aggressive_age_job_queues;
      data.aging_statistics.aggressive_aging_failed := local_data.aging_statistics.aggressive_aging_failed -
            prev_data_p^.aging_statistics.aggressive_aging_failed;
      data.aging_statistics.age_cp_bound_job := local_data.aging_statistics.age_cp_bound_job -
            prev_data_p^.aging_statistics.age_cp_bound_job;
      data.aging_statistics.remove_unmodified_page_from_ws :=
            local_data.aging_statistics.remove_unmodified_page_from_ws -
            prev_data_p^.aging_statistics.remove_unmodified_page_from_ws;
      data.aging_statistics.remove_modified_page_from_ws :=
            local_data.aging_statistics.remove_modified_page_from_ws -
            prev_data_p^.aging_statistics.remove_modified_page_from_ws;
      data.aging_statistics.page_written_to_disk := local_data.aging_statistics.page_written_to_disk -
            prev_data_p^.aging_statistics.page_written_to_disk;
      data.aging_statistics.multiple_pages_written_to_disk :=
            local_data.aging_statistics.multiple_pages_written_to_disk -
            prev_data_p^.aging_statistics.multiple_pages_written_to_disk;
      data.aging_statistics.calls_to_age_jws := local_data.aging_statistics.calls_to_age_jws -
            prev_data_p^.aging_statistics.calls_to_age_jws;
      data.aging_statistics.age_exceeds_aif := local_data.aging_statistics.age_exceeds_aif -
            prev_data_p^.aging_statistics.age_exceeds_aif;
      data.aging_statistics.age_exceeds_aic := local_data.aging_statistics.age_exceeds_aic -
            prev_data_p^.aging_statistics.age_exceeds_aic;
      data.aging_statistics.age_unused_page_in_shared_queue :=
            local_data.aging_statistics.age_unused_page_in_shared_queue -
            prev_data_p^.aging_statistics.age_unused_page_in_shared_queue;
      data.aging_statistics.write_aged_out_page := local_data.aging_statistics.write_aged_out_page -
            prev_data_p^.aging_statistics.write_aged_out_page;
      data.aging_statistics.write_forced_out_page := local_data.aging_statistics.write_forced_out_page -
            prev_data_p^.aging_statistics.write_forced_out_page;
      data.aging_statistics.write_pt_full_page := local_data.aging_statistics.write_pt_full_page -
            prev_data_p^.aging_statistics.write_pt_full_page;
      data.aging_statistics.write_avail_mod_page := local_data.aging_statistics.write_avail_mod_page -
            prev_data_p^.aging_statistics.write_avail_mod_page;
      data.aging_statistics.write_page_failed := local_data.aging_statistics.write_page_failed -
            prev_data_p^.aging_statistics.write_page_failed;

      FOR queue := LOWERBOUND (data.aging_statistics.age_sys_shared_queue)
            TO UPPERBOUND (data.aging_statistics.age_sys_shared_queue) DO
        data.aging_statistics.age_sys_shared_queue [queue] :=
              local_data.aging_statistics.age_sys_shared_queue [queue] -
              prev_data_p^.aging_statistics.age_sys_shared_queue [queue];
      FOREND;

      FOR disk_status := LOWERVALUE (disk_status) TO UPPERVALUE (disk_status) DO
        data.write_page_statistics [disk_status] := local_data.write_page_statistics [disk_status] -
              prev_data_p^.write_page_statistics [disk_status];
      FOREND;

      data.assign_contiguous_pass_cnt.pass_one_count := local_data.assign_contiguous_pass_cnt.pass_one_count -
            prev_data_p^.assign_contiguous_pass_cnt.pass_one_count;
      data.assign_contiguous_pass_cnt.pass_two_count := local_data.assign_contiguous_pass_cnt.pass_two_count -
            prev_data_p^.assign_contiguous_pass_cnt.pass_two_count;
      data.assign_contiguous_pass_cnt.pass_three_count := local_data.assign_contiguous_pass_cnt.
            pass_three_count - prev_data_p^.assign_contiguous_pass_cnt.pass_three_count;

      data.aio_limit_count := local_data.aio_limit_count - prev_data_p^.aio_limit_count;
      data.assign_contig_reject := local_data.assign_contig_reject - prev_data_p^.assign_contig_reject;
      data.jmtr_escaped_allocate := local_data.jmtr_escaped_allocate - prev_data_p^.jmtr_escaped_allocate;
      data.maxws_aio_count := local_data.maxws_aio_count - prev_data_p^.maxws_aio_count;
      data.refs_to_unrec_df_file_inhib := local_data.refs_to_unrec_df_file_inhib -
            prev_data_p^.refs_to_unrec_df_file_inhib;
      data.refs_to_unrec_df_file_term := local_data.refs_to_unrec_df_file_term -
            prev_data_p^.refs_to_unrec_df_file_term;

{ Total Counters:
      data.reassignable_page_frames.now := local_data.reassignable_page_frames.now;
      data.reassignable_page_frames.soon := local_data.reassignable_page_frames.soon;
      data.reassignable_page_frames.swapout_io_not_initiated :=
            local_data.reassignable_page_frames.swapout_io_not_initiated;
      data.reassignable_page_frames.swapout_io_cannot_initiate :=
            local_data.reassignable_page_frames.swapout_io_cannot_initiate;

      data.max_working_set_size := local_data.max_working_set_size;
      data.reserved_page_count := local_data.reserved_page_count;
      data.resident_job_target := local_data.resident_job_target;

      prev_data_p^ := local_data;

    PROCEND p$get_data;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;

    IF wid = 0 THEN
      osp$establish_block_exit_hndlr (^p$abort_handler);
    IFEND;
    IF initial_call THEN
      ofp$open_display (file_name, wid, dpc$wc_sharing, dpc$wk_table, title, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

*if false
{ Set up the labels.

    str [01] := '     AGING STATISTICS                     AGE SHARED QUEUES';
    str [02] := '     Age CP Bound Job:                         Task Service:';
    str [03] := '   Remove Mod WS Page:                           Executable:';
    str [04] := ' Remove Unmod WS Page:                       Non Executable:';
    str [05] := ' Page Written To Disk:                          Device File:';
    str [06] := '    > 1 Pages To Disk:                          File Server:';
    str [07] := '     Calls To Age JWS:                                Other:';
    str [08] := '     > Interval Floor:';
    str [09] := '   > Interval Ceiling:                WRITE PAGE STATISTICS';
    str [10] := ' Age Unused In Shared:                           sucessfull:';
    str [11] := '  Write Aged Out Page:                   Physical IO Reject:';
    str [12] := '  Wri Forced Out Page:                     No File Assigned:';
    str [13] := '  Wri Page Table Full:                           Disk Flaws:';
    str [14] := ' Write Avail Mod Page:                Device Manager Reject:';
    str [15] := '    Write Page Failed:                   Volume Unavailable:';
    str [16] := '                                          Server Terminated:';
    str [17] := '  AGGRESSIVE AGING';
    str [18] := '  Age Shared_Queue:                      REASSIGNABLE PAGES';
    str [19] := '    Age Job Queues:                                     Now:';
    str [20] := '  Aggressive Force:                                    Soon:';
    str [21] := ' Aggressive Failed:                     Swapout IO Not Init:';
    str [22] := '                                     Swapout IO Cannot Init:';
*else
{ Set up the labels.

    str [01] := '     AGING STATISTICS                     AGE SHARED QUEUES';
    str [02] := '     Age CP Bound Job:                         Task Service:';
    str [03] := '   Remove Mod WS Page:                           Executable:';
    str [04] := ' Remove Unmod WS Page:                       Non Executable:';
    str [05] := ' Page Written To Disk:                          Device File:';
    str [06] := '    > 1 Pages To Disk:                          File Server:';
    str [07] := '     Calls To Age JWS:                                Other:';
    str [08] := '     > Interval Floor:';
    str [09] := '   > Interval Ceiling:                WRITE PAGE STATISTICS';
    str [10] := ' Age Unused In Shared:                           sucessfull:';
    str [11] := '                                         Physical IO Reject:';
    str [12] := '     AGGRESSIVE AGING                      No File Assigned:';
    str [13] := '     Age Shared Queue:                           Disk Flaws:';
    str [14] := '       Age Job Queues:                Device Manager Reject:';
    str [15] := '     Aggressive Force:                   Volume Unavailable:';
    str [16] := '    Aggressive Failed:                    Server Terminated:';
    str [17] := '';
    str [18] := 'ASSIGN CONTIGUOUS MEM                    REASSIGNABLE PAGES';
    str [19] := '       Pass One Count:                                  Now:';
    str [20] := '       Pass Two Count:                                 Soon:';
    str [21] := '     Pass Three Count:                  Swapout IO Not Init:';
    str [22] := '               Reject:               Swapout IO Cannot Init:';
    str [23] := '';
    str [24] := '      AIO Limit Count:                      MAXWS AIO Count:';
    str [25] := 'JMTR Escaped Allocate:                  Reserved Page Count:';
    str [26] := 'System max MAXWS Size:                  Reserved Job Target:';
    str [27] := 'Ref To Unrec DF Inhib:                 Ref To Unrec DF Term:';
*ifend

{ Establish base values for the statistics display if they do not already exist.

    IF v$system_line_info = NIL THEN
      ALLOCATE v$system_line_info IN osv$task_shared_heap^;
      v$system_line_info^.initialized := FALSE;
    IFEND;

    IF (total_display = FALSE) AND (v$previous_display_data_p = NIL) THEN
      ALLOCATE v$previous_display_data_p IN osv$task_shared_heap^;
    IFEND;

    ofp$build_system_line (v$system_line_info^, str [0]);
    IF total_display THEN
      p$get_data (NIL, v$previous_data_for_display, data);
    ELSE
      p$get_data (v$previous_display_data_p, v$previous_data_for_display, data);
    IFEND;

{ Set up the statistics.
{  AGING STATISTICS
    pmp$binary_to_ascii_fit (data.aging_statistics.age_cp_bound_job, 10, 10, 10, str [2] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.remove_unmodified_page_from_ws, 10, 10, 10, str [3] (24,
          10));
    pmp$binary_to_ascii_fit (data.aging_statistics.remove_modified_page_from_ws, 10, 10, 10, str [4]
          (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.page_written_to_disk, 10, 10, 10, str [5] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.multiple_pages_written_to_disk, 10, 10, 10, str [6] (24,
          10));
    pmp$binary_to_ascii_fit (data.aging_statistics.calls_to_age_jws, 10, 10, 10, str [7] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.age_exceeds_aif, 10, 10, 10, str [8] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.age_exceeds_aic, 10, 10, 10, str [9] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.age_unused_page_in_shared_queue, 10, 10, 10, str [10] (24,
          10));
*if false
    pmp$binary_to_ascii_fit (data.aging_statistics.write_aged_out_page, 10, 10, 10, str [11] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.write_forced_out_page, 10, 10, 10, str [12] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.write_pt_full_page, 10, 10, 10, str [13] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.write_avail_mod_page, 10, 10, 10, str [14] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.write_page_failed, 10, 10, 10, str [15] (24, 10));
*ifend

{  AGE SHARED QUEUES
    i := 2;
    FOR queue := mmc$pq_shared_first TO mmc$pq_shared_last_sys DO
      pmp$binary_to_ascii_fit (data.aging_statistics.age_sys_shared_queue [queue], 10, 10, 10, str [i] (62,
            10));
      i := i + 1;
    FOREND;

{WRITE PAGE STATISTICS
    i := 10;
    FOR disk_status := LOWERVALUE (disk_status) TO UPPERVALUE (disk_status) DO
      pmp$binary_to_ascii_fit (data.write_page_statistics [disk_status], 10, 10, 10, str [i] (62, 10));
      i := i + 1;
    FOREND;

{  AGGRESSIVE AGING
    pmp$binary_to_ascii_fit (data.aging_statistics.aggressive_age_shared_queue, 10, 10, 10, str [13]
          (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.aggressive_age_job_queues, 10, 10, 10, str [14] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.force_aggressive_aging, 10, 10, 10, str [15] (24, 10));
    pmp$binary_to_ascii_fit (data.aging_statistics.aggressive_aging_failed, 10, 10, 10, str [16] (24, 10));

{ REASSIGNABLE PAGES
    pmp$binary_to_ascii_fit (data.reassignable_page_frames.now, 10, 10, 10, str [19] (62, 10));
    pmp$binary_to_ascii_fit (data.reassignable_page_frames.soon, 10, 10, 10, str [20] (62, 10));
    pmp$binary_to_ascii_fit (data.reassignable_page_frames.swapout_io_not_initiated, 10, 10, 10, str [21] (62,
          10));
    pmp$binary_to_ascii_fit (data.reassignable_page_frames.swapout_io_cannot_initiate, 10, 10, 10,
          str [22] (62, 10));

{ ASSIGN CONTIGUOUS MEMORY
    pmp$binary_to_ascii_fit (data.assign_contiguous_pass_cnt.pass_one_count, 10, 10, 10, str [19] (24, 10));
    pmp$binary_to_ascii_fit (data.assign_contiguous_pass_cnt.pass_two_count, 10, 10, 10, str [20] (24, 10));
    pmp$binary_to_ascii_fit (data.assign_contiguous_pass_cnt.pass_three_count, 10, 10, 10, str [21] (24, 10));
    pmp$binary_to_ascii_fit (data.assign_contig_reject, 10, 10, 10, str [22] (24, 10));

    pmp$binary_to_ascii_fit (data.aio_limit_count, 10, 10, 10, str [24] (24, 10));
    pmp$binary_to_ascii_fit (data.jmtr_escaped_allocate, 10, 10, 10, str [25] (24, 10));
    pmp$binary_to_ascii_fit (data.max_working_set_size, 10, 10, 10, str [26] (24, 10));
    pmp$binary_to_ascii_fit (data.refs_to_unrec_df_file_inhib, 10, 10, 10, str [27] (24, 10));

    pmp$binary_to_ascii_fit (data.maxws_aio_count, 10, 10, 10, str [24] (62, 10));
    pmp$binary_to_ascii_fit (data.reserved_page_count, 10, 10, 10, str [25] (62, 10));
    pmp$binary_to_ascii_fit (data.resident_job_target, 10, 10, 10, str [26] (62, 10));
    pmp$binary_to_ascii_fit (data.refs_to_unrec_df_file_term, 10, 10, 10, str [27] (62, 10));


{ Display the results.
    IF wid <> 0 THEN
      dpp$clear_window (wid, status);
      FOR i := 0 TO max_lines DO
        dpp$put_next_line (wid, str [i], status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND
    ELSE
      FOR i := 0 TO max_lines DO
        clp$put_display (display_control, str [i], clc$trim, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
      clp$close_display (display_control, status);
      osp$disestablish_cond_handler;
    IFEND;

  PROCEND p$memory_manager_stat_display;
?? OLDTITLE ??
?? NEWTITLE := 'P$SHARED_AGING_STAT_DISPLAY', EJECT ??

  PROCEDURE p$shared_aging_stat_display
    (    title: string ( * <= 50);
         total_display: boolean;
         wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      v$queue_names: [STATIC, READ, oss$job_paged_literal] array
            [mmc$pq_shared_first .. mmc$pq_shared_last] of string (13) := [
{             } 'Task Service:',
{             } '     Execute:',
{             } ' Non Execute:',
{             } 'Device Files:',
{             } ' File Server:',
{             } '       Other:',
{             } '     Site_01:',
{             } '     Site_02:',
{             } '     Site_03:',
{             } '     Site_04:',
{             } '     Site_05:',
{             } '     Site_06:',
{             } '     Site_07:',
{             } '     Site_08:',
{             } '     Site_09:',
{             } '     Site_10:',
{             } '     Site_11:',
{             } '     Site_12:',
{             } '     Site_13:',
{             } '     Site_14:',
{             } '     Site_15:',
{             } '     Site_16:',
{             } '     Site_17:',
{             } '     Site_18:',
{             } '     Site_19:',
{             } '     Site_20:',
{             } '     Site_21:',
{             } '     Site_22:',
{             } '     Site_23:',
{             } '     Site_24:',
{             } '     Site_25:'];

    CONST
      c$header_lines = 6;

    TYPE
      t$q_sizes = array [mmc$pq_free .. mmc$pq_shared_last] of t$q_size,
      t$q_size = record
        current: 0 .. osc$max_page_frames,
        difference: integer,
      recend,

      t$display_data = record
        shared_queue_aging_stats: mmt$shared_queue_aging_stats,
        q_sizes: t$q_sizes,
      recend;

    VAR
      v$previous_data_for_display: [STATIC, oss$task_shared] boolean := FALSE,
      v$previous_display_data_p: [STATIC, oss$task_shared] ^t$display_data := NIL,
      v$system_line_info: [STATIC, oss$task_shared] ^oft$system_line_info := NIL;

    VAR
      display_control: clt$display_control,
      data: t$display_data,
      i: integer,
      queue: mmt$page_frame_queue_id,
      str_p: ^array [0 .. * ] of string (80);

?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

{ PURPOSE:
{   This procedure provides clean-up processing when a task abort occurs.

    PROCEDURE p$abort_handler
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           save_area_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      IF wid = 0 THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? NEWTITLE := 'P$GET_DATA', EJECT ??

    PROCEDURE p$get_data
      (    prev_data_p: ^t$display_data;
       VAR previous_data_for_display: boolean;
       VAR data: t$display_data);

      VAR
        local_data: t$display_data,
        queue: mmt$page_frame_queue_id;

      local_data.shared_queue_aging_stats := mmv$aging_statistics.age_shared_queue;
      FOR queue := mmc$pq_free TO mmv$last_active_shared_queue DO
        local_data.q_sizes [queue].current := mmv$gpql [queue].pqle.count;
        local_data.q_sizes [queue].difference := 0;
      FOREND;

      IF (prev_data_p = NIL) OR (previous_data_for_display = FALSE) THEN
        data := local_data;

        IF prev_data_p <> NIL THEN
          prev_data_p^ := local_data;
          previous_data_for_display := TRUE;
        IFEND;
        RETURN; {----->
      IFEND;

      FOR queue := mmc$pq_free TO mmc$pq_shared_first - 1 DO
        data.q_sizes [queue].current := local_data.q_sizes [queue].current;
        data.q_sizes [queue].difference := local_data.q_sizes [queue].
              current - prev_data_p^.q_sizes [queue].current;
      FOREND;

      FOR queue := mmc$pq_shared_first TO mmv$last_active_shared_queue DO
        data.q_sizes [queue].current := local_data.q_sizes [queue].current;
        data.q_sizes [queue].difference := local_data.q_sizes [queue].
              current - prev_data_p^.q_sizes [queue].current;
        data.shared_queue_aging_stats [queue].modified_pages :=
              local_data.shared_queue_aging_stats [queue].modified_pages -
              prev_data_p^.shared_queue_aging_stats [queue].modified_pages;
        data.shared_queue_aging_stats [queue].total_pages :=
              local_data.shared_queue_aging_stats [queue].total_pages -
              prev_data_p^.shared_queue_aging_stats [queue].total_pages;
        data.shared_queue_aging_stats [queue].pages_scanned :=
              local_data.shared_queue_aging_stats [queue].pages_scanned -
              prev_data_p^.shared_queue_aging_stats [queue].pages_scanned;
      FOREND;

      prev_data_p^ := local_data;

    PROCEND p$get_data;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;

    IF wid = 0 THEN
      osp$establish_block_exit_hndlr (^p$abort_handler);
    IFEND;
    IF initial_call THEN
      ofp$open_display (file_name, wid, dpc$wc_sharing, dpc$wk_table, title, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

{ Establish base values for the statistics display if they do not already exist.
    IF v$system_line_info = NIL THEN
      ALLOCATE v$system_line_info IN osv$task_shared_heap^;
      v$system_line_info^.initialized := FALSE;
    IFEND;

    IF (total_display = FALSE) AND (v$previous_display_data_p = NIL) THEN
      ALLOCATE v$previous_display_data_p IN osv$task_shared_heap^;
    IFEND;

    PUSH str_p: [0 .. c$header_lines + (mmv$last_active_shared_queue - mmc$pq_shared_first + 1)];

    ofp$build_system_line (v$system_line_info^, str_p^ [0]);
    IF total_display THEN
      p$get_data (NIL, v$previous_data_for_display, data);
    ELSE
      p$get_data (v$previous_display_data_p, v$previous_data_for_display, data);
    IFEND;

{Setup Lables
    str_p^ [1] := '';
    str_p^ [2] := 'Tot: Free:           Available:           Available-Mod:           Wired:';
    str_p^ [3] := 'Inc: Free:           Available:           Available-Mod:           Wired:';
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_free].current, 10, 6, 6, str_p^ [2] (12, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_avail].current, 10, 6, 6, str_p^ [2] (33, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_avail_modified].current, 10, 6, 6, str_p^ [2] (58, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_wired].current, 10, 6, 6, str_p^ [2] (75, 6));

    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_free].difference, 10, 6, 6, str_p^ [3] (12, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_avail].difference, 10, 6, 6, str_p^ [3] (33, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_avail_modified].difference, 10, 6, 6, str_p^ [3] (58, 6));
    pmp$binary_to_ascii_fit (data.q_sizes [mmc$pq_wired].difference, 10, 6, 6, str_p^ [3] (75, 6));

    str_p^ [4] := '';
    str_p^ [5] := '                                   ----------- Aged Pages ---------';
    str_p^ [6] := 'Shared Queue    Diff   Size    Min    Modified Unmodified      Total    Scanned';
    i := c$header_lines + 1;
    FOR queue := mmc$pq_shared_first TO mmv$last_active_shared_queue DO
      str_p^ [i] := v$queue_names [queue];
      pmp$binary_to_ascii_fit (data.q_sizes [queue].difference, 10, 6, 6, str_p^ [i] (15, 6));
      pmp$binary_to_ascii_fit (data.q_sizes [queue].current, 10, 6, 6, str_p^ [i] (22, 6));
      pmp$binary_to_ascii_fit (mmv$gpql [queue].minimum_actual, 10, 6, 6, str_p^ [i] (29, 6));
      pmp$binary_to_ascii_fit (data.shared_queue_aging_stats [queue].modified_pages, 10, 10, 10,
            str_p^ [i] (37, 10));
      pmp$binary_to_ascii_fit (data.shared_queue_aging_stats [queue].total_pages -
            data.shared_queue_aging_stats [queue].modified_pages, 10, 10, 10, str_p^ [i] (48, 10));
      pmp$binary_to_ascii_fit (data.shared_queue_aging_stats [queue].total_pages, 10, 10, 10, str_p^ [i] (59,
            10));
      pmp$binary_to_ascii_fit (data.shared_queue_aging_stats [queue].pages_scanned, 10, 10, 10,
            str_p^ [i] (70, 10));

      i := i + 1;
    FOREND;

{ Display the results.
    IF wid <> 0 THEN
      dpp$clear_window (wid, status);
      FOR i := 0 TO UPPERBOUND (str_p^) DO
        dpp$put_next_line (wid, str_p^ [i], status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND
    ELSE
      FOR i := 0 TO UPPERBOUND (str_p^) DO
        clp$put_display (display_control, str_p^ [i], clc$trim, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
      clp$close_display (display_control, status);
      osp$disestablish_cond_handler;
    IFEND;

  PROCEND p$shared_aging_stat_display;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$DYNAMIC_AGING_STAT_DISP', EJECT ??

  PROCEDURE [XDCL] ofp$dynamic_aging_stat_disp
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (36) := 'Dynamic Aging Incremental Statistics';

    p$dynamic_aging_stat_display (c$title, FALSE {= incremental} , wid, display_name, file_name, initial_call,
          status);

  PROCEND ofp$dynamic_aging_stat_disp;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$DYNAMIC_AGING_STAT_TOT_DISP', EJECT ??

  PROCEDURE [XDCL] ofp$dynamic_aging_stat_tot_disp
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (30) := 'Dynamic Aging Total Statistics';

    p$dynamic_aging_stat_display (c$title, TRUE {= total} , wid, display_name, file_name, initial_call,
          status);

  PROCEND ofp$dynamic_aging_stat_tot_disp;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$MEM_MANAGER_STAT_TOTAL_DISP', EJECT ??

  PROCEDURE [XDCL] ofp$mem_manager_stat_total_disp
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (31) := 'Memory Manager Total Statistics';

    p$memory_manager_stat_display (c$title, TRUE {= total} , wid, display_name, file_name, initial_call,
          status);

  PROCEND ofp$mem_manager_stat_total_disp;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$MEMORY_MANAGER_STAT_DISPLAY', EJECT ??

  PROCEDURE [XDCL] ofp$memory_manager_stat_display
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (37) := 'Memory Manager Incremental Statistics';

    p$memory_manager_stat_display (c$title, FALSE {= incremental} , wid, display_name, file_name,
          initial_call, status);

  PROCEND ofp$memory_manager_stat_display;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$MEMORY_RING_REQUEST_TRACE', EJECT ??

  PROCEDURE [XDCL] ofp$memory_ring_request_trace
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    CONST
      max_lines = 18;

    TYPE
      t$display_data = array [0 .. 20] of integer;

    VAR
      c$title: [READ, oss$job_paged_literal] string (25) := 'Memory Ring Request Trace';

    VAR
      v$previous_display_data_p: [STATIC, oss$task_shared] ^t$display_data := NIL,
      v$system_line_info: [STATIC, oss$task_shared] ^oft$system_line_info := NIL;

    VAR
      data: t$display_data,
      display_control: clt$display_control,
      i: integer,
      inc: integer,
      str: array [0 .. max_lines] of string (80),
      tot: integer;

?? NEWTITLE := 'P$ABORT_HANDLER', EJECT ??

{ PURPOSE:
{   This procedure provides clean-up processing when a task abort occurs.

    PROCEDURE p$abort_handler
      (    condition: pmt$condition;
           condition_information_p: ^pmt$condition_information;
           save_area_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      IF wid = 0 THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;

    IF wid = 0 THEN
      osp$establish_block_exit_hndlr (^p$abort_handler);
    IFEND;
    IF initial_call THEN
      ofp$open_display (file_name, wid, dpc$wc_sharing, dpc$wk_table, c$title, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
    IFEND;

{ Set up the labels.

    str [01] := '       RING 1 REQUEST TRACE       Total       Incremental';
    str [02] := '      Delete Segment Segnum:';
    str [03] := '        Delete Segment SFID:';
    str [04] := '           Free Image Pages:';
    str [05] := '              Commit Memory:';
    str [06] := '                Detach File:';
    str [07] := '  Flush Delete Segment SFID:';
    str [08] := '       Flush Segment Segnum:';
    str [09] := '               Replace SFID:';
    str [10] := '           End Job Recovery:';
    str [11] := '             Make MFW Cache:';
    str [12] := '    Remove Job Shared Pages:';
    str [13] := '     Change Swap File Queue:';
    str [14] := '         Get Highest Offset:';
    str [15] := ' Delete Job Segment By SFID:';
    str [16] := '      Remove Detached Pages:';
    str [17] := '   Flush Available Modified:';
    str [18] := '          Share Global Logs:';

{ Establish base values for the statistics display if they do not already exist.

    IF v$system_line_info = NIL THEN
      ALLOCATE v$system_line_info IN osv$task_shared_heap^;
      v$system_line_info^.initialized := FALSE;
    IFEND;

    IF v$previous_display_data_p = NIL THEN
      ALLOCATE v$previous_display_data_p IN osv$task_shared_heap^;
      FOR i := 0 TO 16 {= highest used entry} DO
        v$previous_display_data_p^ [i] := 0;
      FOREND;
    IFEND;

    ofp$build_system_line (v$system_line_info^, str [0]);
    FOR i := 0 TO 16 {= highest used entry} DO
      tot := mmv$ring1_request_trace [i];
      inc := tot - v$previous_display_data_p^ [i];
      v$previous_display_data_p^ [i] := tot;

      pmp$binary_to_ascii_fit (tot, 10, 10, 10, str [i + 2] (30, 10));
      pmp$binary_to_ascii_fit (inc, 10, 10, 10, str [i + 2] (48, 10));
    FOREND;

{ Display the results.
    IF wid <> 0 THEN
      dpp$clear_window (wid, status);
      FOR i := 0 TO max_lines DO
        dpp$put_next_line (wid, str [i], status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND
    ELSE
      FOR i := 0 TO max_lines DO
        clp$put_display (display_control, str [i], clc$trim, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      FOREND;
      clp$close_display (display_control, status);
      osp$disestablish_cond_handler;
    IFEND;

  PROCEND ofp$memory_ring_request_trace;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$SHARED_AGING_STAT_TOT_DISP', EJECT ??

  PROCEDURE [XDCL] ofp$shared_aging_stat_tot_disp
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (36) := 'Shared Memory Aging Total Statistics';

    p$shared_aging_stat_display (c$title, TRUE {= total} , wid, display_name, file_name, initial_call,
          status);

  PROCEND ofp$shared_aging_stat_tot_disp;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL] OFP$SHARED_AGING_STAT_INC_DISP', EJECT ??

  PROCEDURE [XDCL] ofp$shared_aging_stat_inc_disp
    (    wid: dpt$window_id;
         display_name: ost$name;
         file_name: amt$local_file_name;
         initial_call: boolean;
     VAR status: ost$status);

    VAR
      c$title: [READ, oss$job_paged_literal] string (42) := 'Shared Memory Aging Incremental Statistics';

    p$shared_aging_stat_display (c$title, FALSE {= incremental} , wid, display_name, file_name, initial_call,
          status);

  PROCEND ofp$shared_aging_stat_inc_disp;
?? OLDTITLE ??
MODEND ofm$memory_manager_stat_display
