?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Program Management: Processor Model Number and Type Equates' ??
MODULE osm$processor_model_equates;

{ PURPOSE:
{   This module provides a single location for all CPU model-dependent information which the system needs
{   at one time or another.  The variable V$PROCESSOR_MODEL_DEFINITIONS is a table which contains information
{   detailing each CPU model's respective name, class, and attributes which the system software will need for
{   execution.  This table reflects some of the information in Table 1.5-2 of the MIGDS and should be updated
{   each time there is a change in the number of CPU models which Control Data Corporation supports.
{
{   Any additional CPU model-dependent information which is needed should be added to the TYPEs declared below
{   and the table should be updated accordingly.  To update the table, add the required information to the
{   table.  The last entry must always remain the UNKNOWN processor model entry.
{
{ NOTE:
{   Several mainframes have the same hardware processor model number but have different characteristics which
{   make the mainframe unique.  (Example:  The CYBER 2000V mainframe has a hardware processor model number of
{   48(16) and a hardware memory model number of 48(16).  A mainframe with a hardware processor model number
{   of 48(16) amd a hardware memory model number of 46(16) is referred to as a CYBER 2000U mainframe.)  To
{   keep mainframes with the same hardware processor model number separate and unique, pseudo model numbers
{   have been created.  Pseudo model numbers exist as place holders in the V$PROCESSOR_MODEL_DEFINITIONS
{   array.  When a call is made to procedures in this module to return a processor definition, a change is
{   made in the caller's definition to contain the real hardware model number rather then the pseudo model
{   number.  This module should be the only area that uses the pseudo model number.
?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc osc$processor_defined_registers
*copyc oss$mainframe_pageable
*copyc oss$mainframe_paged_literal
*copyc ost$iou_model_number
*copyc ost$mainframe_classes
*copyc ost$processor_model_definitions
*copyc ost$processor_model_number
*copyc pmt$processor_model_number
*copyc pmt$processor_model_type
?? POP ??
*copyc dsp$retrieve_mf_element_entry
*copyc osp$system_error
?? EJECT ??
*copyc dsv$sub_mainframe_type
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??
  CONST
    c$max_processor_model_index = 43;

  TYPE
    t$processor_model_index = 0 .. c$max_processor_model_index,

    t$processor_model_definitions = ARRAY [t$processor_model_index] OF ost$processor_model_definition;
?? EJECT ??
?? FMT (FORMAT := OFF) ??
  VAR
    v$global_processor_model_def: [oss$mainframe_pageable] ost$processor_model_definition,
    v$iou_model_number: [oss$mainframe_pageable] ost$processor_model_number,
    v$memory_model_number: [oss$mainframe_pageable] ost$processor_model_number,
    v$processor_model_definitions: [READ, oss$mainframe_paged_literal] t$processor_model_definitions := [

{11}      [osc$cyber_180_model_815,     osc$cyber_180_model_815,     pmc$cyber_180_model_815,
           pmc$cyber_180_model_815_class,   pmc$cyber_180_model_815_class,
           60000, 300000, FALSE, TRUE,  pmc$no_vectors],

{12}      [osc$cyber_180_model_825,     osc$cyber_180_model_825,     pmc$cyber_180_model_825,
           pmc$cyber_180_model_825_class,   pmc$cyber_180_model_825_class,
           50000, 200000, FALSE, TRUE,  pmc$no_vectors],

{13}      [osc$cyber_180_model_830,     osc$cyber_180_model_830,     pmc$cyber_180_model_830,
           pmc$cyber_180_model_830_class,   pmc$cyber_180_model_830_class,
           50000, 200000, FALSE, TRUE,  pmc$no_vectors],

{14}      [osc$cyber_180_model_810,     osc$cyber_180_model_810,     pmc$cyber_180_model_810,
           pmc$cyber_180_model_810_class,   pmc$cyber_180_model_810_class,
           60000, 300000, FALSE, TRUE,  pmc$no_vectors],

{20}      [osc$cyber_180_model_835,     osc$cyber_180_model_835,     pmc$cyber_180_model_835,
           pmc$cyber_180_model_835_class,   pmc$cyber_180_model_835_class,
           40000, 100000, TRUE,  TRUE,  pmc$no_vectors],

{30}      [osc$cyber_180_model_855,     osc$cyber_180_model_855,     pmc$cyber_180_model_855,
           pmc$cyber_180_model_855_class,   pmc$cyber_180_model_855_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{31}      [osc$cyber_180_model_845,     osc$cyber_180_model_845,     pmc$cyber_180_model_845,
           pmc$cyber_180_model_845_class,   pmc$cyber_180_model_845_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

          { A dual-cpu 860 is an 870 class machine.}

{32}      [osc$cyber_180_model_860,     osc$cyber_180_model_860,     pmc$cyber_180_model_860,
           pmc$cyber_180_model_860_class,   pmc$cyber_180_model_870_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{33}      [osc$cyber_180_model_850,     osc$cyber_180_model_850,     pmc$cyber_180_model_850,
           pmc$cyber_180_model_850_class,   pmc$cyber_180_model_850_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{34}      [osc$cyber_180_model_840,     osc$cyber_180_model_840,     pmc$cyber_180_model_840,
           pmc$cyber_180_model_840_class,   pmc$cyber_180_model_840_class,
           40000, 100000, TRUE,  TRUE,  pmc$no_vectors],

{35}      [osc$cyber_180_model_845s,    osc$cyber_180_model_845s,    pmc$cyber_180_model_845s,
           pmc$cyber_180_model_845s_class,  pmc$cyber_180_model_845s_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{36}      [osc$cyber_180_model_855s,    osc$cyber_180_model_855s,    pmc$cyber_180_model_855s,
           pmc$cyber_180_model_855s_class,  pmc$cyber_180_model_855s_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{37}      [osc$cyber_180_model_840s,    osc$cyber_180_model_840s,    pmc$cyber_180_model_840s,
           pmc$cyber_180_model_840s_class,  pmc$cyber_180_model_840s_class,
           30000, 50000,  FALSE, FALSE, pmc$no_vectors],

          { A dual-cpu 9603 is a 960-32 machine.}

{3A}      [osc$cyber_900_model_9603,    osc$cyber_900_model_9603,    pmc$cyber_900_model_9603,
           pmc$cyber_900_model_96031_class, pmc$cyber_900_model_96032_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{3B}      [osc$cyber_900_model_9601,    osc$cyber_900_model_9601,    pmc$cyber_900_model_9601,
           pmc$cyber_900_model_96011_class, pmc$cyber_900_model_96011_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{3C}      [osc$cyber_900_model_960d,    osc$cyber_900_model_960d,    pmc$cyber_900_model_960d,
           pmc$cyber_900_model_96031_class, pmc$cyber_900_model_96032_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{3D}      [osc$cyber_900_model_960c,    osc$cyber_900_model_960c,    pmc$cyber_900_model_960c,
           pmc$cyber_900_model_96011_class, pmc$cyber_900_model_96011_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

          { A dual-cpu 990 is a 995 class machine.}

{40}      [osc$cyber_180_model_990,     osc$cyber_180_model_990,     pmc$cyber_180_model_990,
           pmc$cyber_180_model_990_class,   pmc$cyber_180_model_995_class,
           30000, 50000,  TRUE,  TRUE,  pmc$standard_vectors],

          { A dual-cpu 990E is a 995 class machine.}

{41}      [osc$cyber_180_model_990e,    osc$cyber_180_model_990e,    pmc$cyber_180_model_990e,
           pmc$cyber_180_model_990_class,   pmc$cyber_180_model_995_class,
           30000, 50000,  TRUE,  TRUE,  pmc$standard_vectors],

          { A dual-cpu 992 is a 992-32 class machine.}

{42}      [osc$cyber_900_model_992,     osc$cyber_900_model_992,     pmc$cyber_900_model_992,
           pmc$cyber_900_model_99231_class, pmc$cyber_900_model_99232_class,
           30000, 50000,  TRUE,  TRUE,  pmc$standard_vectors],

{43}      [osc$cyber_900_model_992a,    osc$cyber_900_model_992a,    pmc$cyber_900_model_992a,
           pmc$cyber_900_model_99231_class, pmc$cyber_900_model_99232_class,
           30000, 50000,  TRUE,  TRUE,  pmc$standard_vectors],

          { A dual-cpu 994 is a 994-32 class machine.}

{44}      [osc$cyber_900_model_994,     osc$cyber_900_model_994,     pmc$cyber_900_model_994,
           pmc$cyber_900_model_99431_class, pmc$cyber_900_model_99432_class,
           30000, 50000,  TRUE,  TRUE,  pmc$standard_vectors],

{46}      [osc$cyber_2000_model_20s1,   osc$cyber_2000_model_20s1,   pmc$cyber_2000_model_20s1,
           pmc$cyber_2000_model_20s1_class, pmc$cyber_2000_model_20s2_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{47}      [osc$cyber_2000_model_20u1,   osc$cyber_2000_model_20v1,   pmc$cyber_2000_model_20u1,
           pmc$cyber_2000_model_20u1_class, pmc$cyber_2000_model_20u2_class,
           30000, 50000,  TRUE,  TRUE,  pmc$extended_vectors],

{48}      [osc$cyber_2000_model_20v1,   osc$cyber_2000_model_20v1,   pmc$cyber_2000_model_20v1,
           pmc$cyber_2000_model_20v1_class, pmc$cyber_2000_model_20v2_class,
           30000, 50000,  TRUE,  TRUE,  pmc$extended_vectors],

{51}      [osc$cyber_180_model_930d,    osc$cyber_180_model_930d,    pmc$cyber_180_model_930d,
           pmc$cyber_180_model_930d_class,  pmc$cyber_180_model_930d_class,
           50000, 200000, TRUE,  TRUE,  pmc$no_vectors],

{52}      [osc$cyber_180_model_9303,    osc$cyber_180_model_9303,    pmc$cyber_180_model_9303,
           pmc$cyber_180_model_93031_class, pmc$cyber_180_model_93031_class,
           40000, 100000, TRUE,  TRUE,  pmc$no_vectors],

{53}      [osc$cyber_180_model_9301,    osc$cyber_180_model_9301,    pmc$cyber_180_model_9301,
           pmc$cyber_180_model_93011_class, pmc$cyber_180_model_93011_class,
           50000, 200000, TRUE,  TRUE,  pmc$no_vectors],

{54}      [osc$cyber_900_model_9323,    osc$cyber_900_model_9323,    pmc$cyber_900_model_9323,
           pmc$cyber_900_model_93231_class, pmc$cyber_900_model_93232_class,
           40000, 100000, TRUE,  FALSE, pmc$no_vectors],

{55}      [osc$cyber_900_model_9321,    osc$cyber_900_model_9321,    pmc$cyber_900_model_9321,
           pmc$cyber_900_model_93211_class, pmc$cyber_900_model_93211_class,
           50000, 200000, TRUE,  FALSE, pmc$no_vectors],

{5B}      [osc$cyber_180_model_930a,    osc$cyber_180_model_930a,    pmc$cyber_180_model_930a,
           pmc$cyber_180_model_930a_class,  pmc$cyber_180_model_930a_class,
           50000, 200000, TRUE,  TRUE,  pmc$no_vectors],

{5C}      [osc$cyber_900_model_932a,    osc$cyber_900_model_932a,    pmc$cyber_900_model_932a,
           pmc$cyber_900_model_932a_class,  pmc$cyber_900_model_932a_class,
           40000, 100000, TRUE,  FALSE, pmc$no_vectors],

{5D}      [osc$cyber_180_model_930b,    osc$cyber_180_model_930b,    pmc$cyber_180_model_930b,
           pmc$cyber_180_model_930b_class,  pmc$cyber_180_model_930b_class,
           40000, 100000, TRUE,  TRUE,  pmc$no_vectors],

{5E}      [osc$cyber_180_model_930c,    osc$cyber_180_model_930c,    pmc$cyber_180_model_930c,
           pmc$cyber_180_model_930c_class,  pmc$cyber_180_model_930c_class,
           50000, 200000, TRUE,  TRUE,  pmc$no_vectors],

{5F}      [osc$cyber_900_model_932b,    osc$cyber_900_model_932b,    pmc$cyber_900_model_932b,
           pmc$cyber_900_model_932b_class,  pmc$cyber_900_model_932b_class,
           40000, 100000, TRUE,  FALSE, pmc$no_vectors],

{F8}      [osc$cyber_900_model_9703,    osc$cyber_900_model_9603,    pmc$cyber_900_model_9703,
           pmc$cyber_900_model_97031_class, pmc$cyber_900_model_97032_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{F9}      [osc$cyber_900_model_9701,    osc$cyber_900_model_9601,    pmc$cyber_900_model_9701,
           pmc$cyber_900_model_97011_class, pmc$cyber_900_model_97011_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FA}      [osc$cyber_900_model_970d,    osc$cyber_900_model_960d,    pmc$cyber_900_model_970d,
           pmc$cyber_900_model_97031_class, pmc$cyber_900_model_97032_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FB}      [osc$cyber_900_model_970c,    osc$cyber_900_model_960c,    pmc$cyber_900_model_970c,
           pmc$cyber_900_model_97011_class, pmc$cyber_900_model_97011_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FC}      [osc$cyber_900_model_9723,    osc$cyber_900_model_9603,    pmc$cyber_900_model_9723,
           pmc$cyber_900_model_97231_class, pmc$cyber_900_model_97232_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FD}      [osc$cyber_900_model_9721,    osc$cyber_900_model_9601,    pmc$cyber_900_model_9721,
           pmc$cyber_900_model_97211_class, pmc$cyber_900_model_97211_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FE}      [osc$cyber_900_model_972d,    osc$cyber_900_model_960d,    pmc$cyber_900_model_972d,
           pmc$cyber_900_model_97231_class, pmc$cyber_900_model_97232_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{FF}      [osc$cyber_900_model_972c,    osc$cyber_900_model_960c,    pmc$cyber_900_model_972c,
           pmc$cyber_900_model_97211_class, pmc$cyber_900_model_97211_class,
           30000, 50000,  TRUE,  TRUE,  pmc$no_vectors],

{UNKNOWN} [osc$cyber_180_model_unknown, osc$cyber_180_model_unknown, pmc$cyber_180_model_unknown,
           pmc$cyber_180_unknown_class,     pmc$cyber_180_unknown_class,
           30000, 50000,  FALSE, FALSE, pmc$no_vectors]];
?? FMT (FORMAT := ON) ??
?? OLDTITLE ??
?? NEWTITLE := 'convert_to_pseudo_model_number', EJECT ??

{ PURPOSE:
{   This procedure converts the real hardware model number into the pseudo model number.
{
{   1)  A Cyber 2000 mainframe with a CPU model number of 48(16) and a Memory model number of 46(16)
{       becomes known as a '20U1' mainframe.
{
{   2)  The 960x group of mainframes with a Memory model number of 35(16) and an Iou model number of 40(16)
{       becomes known as 970x mainframes.
{
{   3)  The 960x group of mainframes with a Memory model number of 35(16) and an Iou model number of 44(16)
{       becomes known as 972x mainframes.

  PROCEDURE convert_to_pseudo_model_number
    (    real_hardware_model_number: ost$processor_model_number;
     VAR pseudo_model_number: ost$processor_model_number);

    CONST
      c$memory_model_35 = 35(16),  {4 mega bit DRAM chip.
      c$memory_model_46 = 46(16);

    pseudo_model_number := real_hardware_model_number;

    { Determine the pseudo_model_number for mainframes with a Memory model number 35(16).

    IF v$memory_model_number = c$memory_model_35 THEN

      { 960x mainframes with a memory model 35(16) and a I4 primary IOU are referred to as 970x mainframes.

      IF v$iou_model_number = osc$imn_40 THEN
        IF real_hardware_model_number = osc$cyber_900_model_9603 THEN
          pseudo_model_number := osc$cyber_900_model_9703;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_9601 THEN
          pseudo_model_number := osc$cyber_900_model_9701;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_960d THEN
          pseudo_model_number := osc$cyber_900_model_970d;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_960c THEN
          pseudo_model_number := osc$cyber_900_model_970c;
        IFEND;

      { 960x mainframes with a memory model 35(16) and a I4C primary IOU are referred to as 972x mainframes.

      ELSEIF v$iou_model_number = osc$imn_44 THEN
        IF real_hardware_model_number = osc$cyber_900_model_9603 THEN
          pseudo_model_number := osc$cyber_900_model_9723;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_9601 THEN
          pseudo_model_number := osc$cyber_900_model_9721;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_960d THEN
          pseudo_model_number := osc$cyber_900_model_972d;
        ELSEIF real_hardware_model_number = osc$cyber_900_model_960c THEN
          pseudo_model_number := osc$cyber_900_model_972c;
        IFEND;
      IFEND;

    { Determine the pseudo_model_number for 2000 mainframes with a CPU model number 48(16) and a Memory model
    { number 46(16).

    ELSEIF (real_hardware_model_number = osc$cyber_2000_model_20v1) AND
          (v$memory_model_number = c$memory_model_46) THEN
      pseudo_model_number := osc$cyber_2000_model_20u1;

    IFEND;

  PROCEND convert_to_pseudo_model_number;
?? OLDTITLE ??
?? NEWTITLE := 'osp$check_for_desired_mf_class', EJECT ??

{ PURPOSE:
{   This procedure determines if the mainframe currently running is of the desired class.

  PROCEDURE [XDCL, #GATE] osp$check_for_desired_mf_class
    (    desired_class: ost$mainframe_classes;
     VAR desired_class_found: boolean);

    CASE desired_class OF
    = osc$mc_china_class =
      desired_class_found := (dsv$sub_mainframe_type = dsc$smt_china_mainframe);
    = osc$mc_soviet_class =
      desired_class_found := (dsv$sub_mainframe_type = dsc$smt_soviet_mainframe);
    = osc$mc_china_or_soviet_class =
      desired_class_found := ((dsv$sub_mainframe_type = dsc$smt_china_mainframe) OR
            (dsv$sub_mainframe_type = dsc$smt_soviet_mainframe));
    ELSE
      desired_class_found := FALSE;
    CASEND;

  PROCEND osp$check_for_desired_mf_class;
?? OLDTITLE ??
?? NEWTITLE := 'osp$convert_to_real_model_num', EJECT ??

{ PURPOSE:
{   This procedure converts the pseudo cpu model number into the real hardware cpu model number.

  PROCEDURE [XDCL, #GATE] osp$convert_to_real_model_num
    (    pseudo_model_number: ost$processor_model_number;
     VAR real_model_number: ost$processor_model_number);

    IF (pseudo_model_number = osc$cyber_900_model_9703) OR
          (pseudo_model_number = osc$cyber_900_model_9723) THEN
      real_model_number := osc$cyber_900_model_9603;
    ELSEIF (pseudo_model_number = osc$cyber_900_model_9701) OR
          (pseudo_model_number = osc$cyber_900_model_9721) THEN
      real_model_number := osc$cyber_900_model_9601;
    ELSEIF (pseudo_model_number = osc$cyber_900_model_970d) OR
          (pseudo_model_number = osc$cyber_900_model_972d) THEN
      real_model_number := osc$cyber_900_model_960d;
    ELSEIF (pseudo_model_number = osc$cyber_900_model_970c) OR
          (pseudo_model_number = osc$cyber_900_model_972c) THEN
      real_model_number := osc$cyber_900_model_960c;
    ELSEIF pseudo_model_number = osc$cyber_2000_model_20u1 THEN
      real_model_number := osc$cyber_2000_model_20v1;
    ELSE
      real_model_number := pseudo_model_number;
    IFEND;

  PROCEND osp$convert_to_real_model_num;
?? OLDTITLE ??
?? NEWTITLE := 'osp$get_cpu_model_definition', EJECT ??

{ PURPOSE:
{   This procedure retrieves the processor model definition for a specific model number.  Searching by real
{   model number is only valid when running on the actual machine.

  PROCEDURE [XDCL, #GATE] osp$get_cpu_model_definition
    (    search_data: ost$processor_search_data;
     VAR definition_found: boolean;
     VAR processor_model_definition: ost$processor_model_definition);

    VAR
      index: t$processor_model_index,
      pseudo_model_number: ost$processor_model_number;

    definition_found := FALSE;

    IF search_data.search_mode = osc$psm_by_pseudo_model_number THEN
      FOR index := LOWERBOUND (v$processor_model_definitions) TO UPPERBOUND (v$processor_model_definitions) DO
        IF v$processor_model_definitions [index].pseudo_model_number = search_data.pseudo_model_number THEN
          definition_found := TRUE;
          processor_model_definition := v$processor_model_definitions [index];
          RETURN;
        IFEND;
      FOREND;

    ELSEIF search_data.search_mode = osc$psm_by_real_model_number THEN
      convert_to_pseudo_model_number (search_data.real_model_number, pseudo_model_number);
      FOR index := LOWERBOUND (v$processor_model_definitions) TO UPPERBOUND (v$processor_model_definitions) DO
        IF v$processor_model_definitions [index].pseudo_model_number = pseudo_model_number THEN
          definition_found := TRUE;
          processor_model_definition := v$processor_model_definitions [index];
          RETURN;
        IFEND;
      FOREND;

    ELSE  {search_data.search_mode = osc$psm_by_model_number_string}
      FOR index := LOWERBOUND (v$processor_model_definitions) TO UPPERBOUND (v$processor_model_definitions) DO
        IF v$processor_model_definitions [index].model_number_string = search_data.model_number_string THEN
          definition_found := TRUE;
          processor_model_definition := v$processor_model_definitions [index];
          RETURN;
        IFEND;
      FOREND;
    IFEND;

  PROCEND osp$get_cpu_model_definition;
?? OLDTITLE ??
?? NEWTITLE := 'osp$get_global_cpu_model_def', EJECT ??

{ PURPOSE:
{   This procedure retrieves the global processor model definition.

  PROCEDURE [XDCL, #GATE] osp$get_global_cpu_model_def
    (VAR global_processor_model_def: ost$processor_model_definition);

    global_processor_model_def := v$global_processor_model_def;

  PROCEND osp$get_global_cpu_model_def;
?? OLDTITLE ??
?? NEWTITLE := 'osp$set_global_cpu_model_def', EJECT ??

{ PURPOSE:
{   This procedure sets the global processor model information definition.

  PROCEDURE [XDCL, #GATE] osp$set_global_cpu_model_def;

    TYPE
      t$integer_or_element_id = RECORD
        CASE boolean OF
        = TRUE =
          integer_part: integer,
        = FALSE =
          rfu: 0 .. 0ffffffff(16),
          element_number: 0 .. 0ff(16),
          model_number: 0 .. 0ff(16),
          serial_number: 0 .. 0ffff(16),
        CASEND,
      RECEND;

    VAR
      definition_found: boolean,
      element_entry: dst$mf_element_table_entry,
      integer_or_element_id: t$integer_or_element_id,
      local_status: ost$status,
      search_data: ost$processor_search_data;

    dsp$retrieve_mf_element_entry (0, dsc$dftb_eid_memory_element, element_entry, local_status);
    IF NOT local_status.normal THEN
      osp$system_error (' Memory element entry not found.', NIL);
    IFEND;
    v$memory_model_number := element_entry.model_number;

    dsp$retrieve_mf_element_entry (0, dsc$dftb_eid_iou0_element, element_entry, local_status);
    IF NOT local_status.normal THEN
      osp$system_error (' IOU element entry not found.', NIL);
    IFEND;
    v$iou_model_number := element_entry.model_number;

    integer_or_element_id.integer_part := #READ_REGISTER (osc$pr_element_id);

    search_data.search_mode := osc$psm_by_real_model_number;
    search_data.real_model_number := integer_or_element_id.model_number;
    osp$get_cpu_model_definition (search_data, definition_found, v$global_processor_model_def);
    IF NOT definition_found THEN
      osp$system_error (' Processor model number unsupported.', NIL);
    IFEND;

  PROCEND osp$set_global_cpu_model_def;
?? OLDTITLE ??
MODEND osm$processor_model_equates;
