1.1 DOCUMENT IDENTIFICATION

This is the Operational Software Objectives Document for the Ada Compiler Evaluation System (ACES), Version 2.1. It was produced by CTA INCORPORATED as CDRL A0014, Task 15 (ACES Version 2.1 Development), contract number F33600-92- D090125. This contract is directed by the Business Software Branch (88 CG/SCTL), United States Air Force, Wright-Patterson AFB, Ohio.

1.2 PURPOSE

This document states the requirements for the revision of the Operational Software Computer Software Configuration Item (CSCI) of the ACES. The principal changes anticipated in this CSCI are the addition of performance tests for a broad range of language features introduced by the 1995 revision of the Ada language standard.

1.3 OVERVIEW

This document is divided into 8 sections, describing the system, the CSCI, relevant documents, and requirements. An appendix describes the disposition of the performance test objectives stated in the previous version of the document,. The following list presents a brief description of the contents of each section and the appendix.

* Section 1 Introduction This is the current section, which identifies and describes the purpose and structure of the document.

* Section 2 Applicable Documents This section lists documents that are referenced in or otherwise relevant to the Objectives document.

* Section 3 System Overview This section gives a high-level description of the purpose and structure of the Ada Compiler Evaluation System.

* Section 4 CSCI Overview This section gives a summary description of the purpose and structure of the Operational Software CSCI of the ACES.

* Section 5 Performance Test Objectives This section states the requirements for performance tests to be added to Version 2.1 of the ACES. Both high and medium priority requirements are identified. It is not anticipated that all the stated test objectives will be implemented.

* Section 6 Resolution of Incompatibilities This section identifies remaining ACES Operational Software incompatibilities with the Ada 95 standard and states the requirements for removing them.

* Section 7 Requirements for Other Changes This section states requirements for any ACES Operational Software changes for Version 2.1 that are not addressed in the previous sections.

* Section 8 Abbreviations and Acronyms This section defines abbreviations and acronyms that are used in this and other ACES documents.

* Appendix A Disposition of 1994 Test Objectives This appendix discusses the disposition of each of the objectives stated in the Operational Software Objectives Document for ACES Version 2.0.

Each requirement identified in Sections 5 through 8 has an associated 3-part identifier of the form "OPS-x-dddd". In these identifiers, "OPS" indicates that the requirement is for the Operational Software CSCI. (Requirements for the Support Software CSCI use "SPT" similarly.) The "x" component is replaced by "T" if the requirement is for a performance test, "S" for command scripts, or "D" for documentation. The "dddd" component is a numerical encoding of the section, subsection, and paragraph number in which the requirement appears. Thus, for example, "OPS-T-5314" identifies a requirement for the Operational Software CSCI, specifically for a test, appearing in Section 5.3.14 of this document.

2 APPLICABLE DOCUMENTS

The following Government and non-Government documents are referenced or are relevant to this Objectives Document.

2.1 GOVERNMENT DOCUMENTS

ANSI/MIL-STD-1815A Reference Manual for the Ada Programming Language (LRM)

Readers Guide for Ada Compiler Evaluation System (ACES), Version 2.0 High Order Language Control Facility Business Software Support Branch 88 CG/SCTL Wright-Patterson AFB OH

Version Description Document (VDD) for Ada Compiler Evaluation System (ACES), Version 2.0 High Order Language Control Facility Business Software Support Branch 88 CG/SCTL Wright-Patterson AFB OH

Primer for Ada Compiler Evaluation System (ACES), Version 2.0 High Order Language Control Facility Business Software Support Branch 88 CG/SCTL Wright-Patterson AFB OH

User's Guide for Ada Compiler Evaluation System (ACES), Version 2.0 High Order Language Control Facility Business Software Support Branch 88 CG/SCTL Wright-Patterson AFB OH

Operational Software Objectives Document for Ada Compiler Evaluation System (ACES), Version 2.0 High Order Language Control Facility Business Software Support Branch 88 CG/SCTL Wright-Patterson AFB OH

2.2 NON-GOVERNMENT DOCUMENTS

ISO/IEC 8652 (1995) Programming Language Ada, Language and Standard Libraries (RM 95)

3 SYSTEM OVERVIEW

The Ada Compiler Evaluation System (ACES) is a set of software tools, source code, scripted scenarios, and documentation. Its purpose is to help assess quality factors of Ada implementations. (An Ada implementation consists of a host computer, a target computer, operating systems for the two computers, and an Ada compilation system.) The ACES can provide compile-time performance data, run-time performance data, and system usability data. The ACES analysis programs can be used to compare the performance of two or more Ada implementations, or they can be used to indicate ways to get the best performance out of a particular implementation.

The ACES is sponsored by the Ada Joint Program Office (AJPO). Version 1.0 was developed by Boeing Defense and Space Group; subsequent versions have been (are being) developed by CTA INCORPORATED.

The ACES software is organized into two Computer Software Configuration Items (CSCIs), referred to as the Operational Software and the Support Software. The Operational Software CSCI consists of performance tests, usability assessor software, and sample command scripts for processing these software modules. The Support Software CSCI consists of library support units, test management software, analysis software, and a Quick-Look (restricted performance testing) facility.

4 CSCI OVERVIEW

The Operational Software CSCI of the ACES consists of performance tests, usability assessor software, and sample command scripts for processing these units. The sponsor's direction for Version 2.1 does not include any modification to the usability assessors; thus, this document does not address them further.

4.1 PERFORMANCE TEST ORGANIZATION (VERSION 2.0)

The performance tests (and associated sample command scripts) are organized into Test Groups. Each group contains tests that attempt to measure an Ada implementation's performance characteristics with respect to a set of related language features (e.g., Storage Reclamation or Tasking) or an area of general interest in computer performance measurement (e.g., Classical benchmarks or Application samples). The tests are written without timing code; this code is automatically inserted into the test sources before compilation begins. The testing process can produce measurements of compile time, link time, execution time, and code size.

Version 2.0 contains 18 performance test groups. Of these, 17 groups contain tests that are compatible with Ada 83. In Version 2.0, all the tests that are specific to Ada 95 are encapsulated within the Ada 95 test group. Due to budget restrictions, only 19 Ada 95 tests were placed in Version 2.0.

4.2 DIRECTION FOR VERSION 2.1

As directed by the sponsor, Version 2.1 will include broad performance testing of the Ada language core, as defined in Sections 2 through 13 and Annexes A and B of the language standard. Tests that match the purpose of existing test groups will be added to the appropriate group (e.g., tests for the precision of the new "delay until" statement will be added to the existing Delays and Timing group). New test groups will be added only as necessary.

5 PERFORMANCE TEST OBJECTIVES

This section states the requirements for performance tests to be added to Version 2.1 of the ACES. It describes the strategy for identifying the requirements, the proposed strategy for implementing them and the high and medium priority test objectives (with recommended depth of coverage). The low priority test objectives are not considered to be requirements, and are identified by topic in Appendix B.

5.1 STRATEGY FOR DEVELOPING TEST OBJECTIVES

The goal for the Operational Software of Version 2.0 of the ACES, as determined by the AJPO, is to provide performance testing with the broadest possible coverage (within resource constraints) of the new features of the core of Ada 95. In particular, the scope of the revision effort does not include extended testing of features already present in Ada 83; neither does it include any testing of features already present in Ada 83; neither does it include any testing of features specified in the Specialized Needs Annexes (Annexes C through G) of the LRM 95.

In keeping with this goal, the analysis team first attempted to prepare a complete list of topics that are new to the core language. Several sources were used for determining the initial list of test topics. First, the Annotated Ada Reference Manual (AARM) was searched for all topics identified as incompatibilities, inconsistencies, or extensions to Ada 83. Next, the Ada Reference Manual was searched and topics that were not so flagged in the AARM (but were new in Ada 95) were identified. Then, the objectives of the executable Ada 95 tests in Version 2.0 of the Ada Compiler Validation Capability (ACVC) were studied to identify any cases that seemed to have a performance impact. Finally, the topics recommended for test objectives in the Operational Software Objectives Document for the ACES Version 2.0 were added to the list.

The initial list of topics was submitted (via electronic mail) for public review and comment. The list was then reduced by eliminating topics that did not appear to have any performance impact. Next, in an iterative fashion, test objectives were created for the remaining topics, and these objectives were submitted for public review. Finally, testing scenarios and test counts were developed for the objectives, along with proposed priorities, and the results were again submitted for review. The resulting objectives that were classified as having high and medium priority are presented in Sections 5.3 and 5.4 of this document. The testing scenarios and identification of specific tests will appear in the Software Design Document for the Operational Software CSCI.

5.2 PLANS FOR IMPLEMENTING TEST OBJECTIVES

The test objectives presented in the next two sections are to be viewed as requirements in a somewhat restricted sense. Since resources are limited, it is not likely that all the objectives will be implemented. During the design phase of this effort, individual tests will be specified for all the high-priority objectives and as many of the medium-priority objectives as resources permit. During the development phase, code will be developed for as many of the specified tests as possible. It is anticipated that all the high-priority objectives will be fully implemented. Coding of medium-priority tests will not begin until it is clear that all the high-priority objectives will be implemented.



5.3 HIGH PRIORITY TEST OBJECTIVES

The following objectives have been identified as being high-priority candidates for ACES 2.1 performance test requirements. As such, they will be the first to be implemented. If time and resources permit, these objectives will be fully implemented.

5.3.1 String Representation of Scalar Values (OPS-T-5301)

The ACES shall determine the performance characteristics of conversions between enumeration or numeric (integer, modular, float, fixed, decimal) types and String, using attributes and instantiations of the generic IO packages in Text_IO.

5.3.2 Real Attributes (OPS-T-5302)

The ACES shall determine the performance characteristics of the "Succ" and "Pred" attributes for real types.

5.3.3 Subprograms as Parameters (OPS-T-5303)

The ACES shall determine the performance of a subprogram call when the subprogram is passed to the calling subprogram via an access-to-subprogram parameter.

5.3.4 Decimal Operations (OPS-T-5304)

The ACES shall determine the performance characteristics of decimal type operations (if supported).

5.3.5 Access Parameters (OPS-T-5305)

The ACES shall determine the performance impact of referencing and assigning to an object designated by a subprogram's formal access parameter.

5.3.6 Assignment for Controlled Types (OPS-T-5306)

The ACES shall determine the performance of assignment of controlled types.

5.3.7 Finalization for Controlled Types (OPS-T-5307)

The ACES shall determine the performance of user-defined finalization when exiting the scope of a controlled object.

5.3.8 Calls on Protected Operations (OPS-T-5308)

The ACES shall determine the time required for a call on a protected operation in the simplest of cases.

5.3.9 Requeue (OPS-T-5309)

The ACES shall determine the performance characteristics of the requeue statement.

5.3.10 Delay Until (OPS-T-5310)

The ACES shall determine the performance characteristics of the delay until statement.

5.3.11 Asynchronous Transfer of Control (OPS-T-5311)

The ACES shall investigate the performance characteristics of asynchronous transfer of control in various scenarios.

5.3.12 Child Library Units (OPS-T-5312)

The ACES shall determine the performance characteristics of references to entities in child packages.

5.3.13 Exception Operations (OPS-T-5313)

The ACES shall determine the performance characteristics of the operations in package Ada.Exceptions.

5.3.14 Address Operations (OPS-T-5314)

The ACES shall determine the performance characteristics of the address arithmetic operations declared in the package System.Storage_Elements.

5.3.15 Address-access Conversions (OPS-T-5315)

The ACES shall determine the performance characteristics of the conversion operations declared in the package System.Address_To_Access_Conversions.

5.3.16 Storage Management (OPS-T-5316)

The ACES shall determine the performance characteristics of the storage management operations declared in the package System.Storage_Pools.

5.3.17 Stream Subprogram Attributes (OPS-T-5317)

The ACES shall determine the performance characteristics of passing data among units by using the stream operations given by attributes.

5.3.18 Strings.Fixed Operations (OPS-T-5318)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Fixed.

5.3.19 Strings.Bounded Operations (OPS-T-5319)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Bounded.

5.3.20 Strings.Unbounded Operations (OPS-T-5320)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Unbounded.

5.3.21 Elementary Functions (OPS-T-5321)

The ACES shall determine the performance characteristics of the operations declared in Ada.Numerics.Elementary_Functions and in an instantiation of Ada.Numerics.Generic_Elementary_Functions, using Float.

5.3.22 Discrete Random Functions (OPS-T-5322)

The ACES shall determine the performance characteristics of the random value function declared in instantiations of Ada.Numerics.Discrete_Random.

5.3.23 Shift and Rotate Operations (OPS-T-5323)

The ACES shall determine the performance characteristics of the shift and rotate operations provided by package Ada.Interfaces.

5.3.24 Interface to Other Languages (OPS-T-5324)

The ACES shall determine the performance characteristics of calls to subprograms written in C, C++, Fortran, and COBOL, as supported by the specific implementation.

5.3.25 Data Representation for C Interfaces (OPS-T-5325)

The ACES shall determine the performance characteristics of the operations provided by package Ada.Interfaces.C.

5.3.26 String Conversions for C Interfaces (OPS-T-5326)

The ACES shall determine the performance characteristics of the operations provided by package Ada.Interfaces.C.Strings.

5.3.27 Pointer Representation for C Interfaces (OPS-T-5327)

The ACES shall determine the performance characteristics of the operations provided by package Ada.Interfaces.C.Pointers.

5.3.28 Data Representation for COBOL Interfaces (OPS-T-5328)

The ACES shall determine the performance characteristics of the operations provided by package Ada.Interfaces.COBOL.

5.3.29 Data Representation for Fortran Interfaces (OPS-T-5329)

The ACES shall determine the performance characteristics of the operations provided by package Ada.Interfaces.Fortran.

5.3.30 Initialize for Controlled Types (OPS-T-5330)

The ACES shall determine the performance characteristics of user-defined Initialize for controlled types.

5.3.31 Child Library Units Implementing Object Classes (OPS-T-5331)

The ACES shall determine the performance characteristics of implementations ob object classes using child library units.

5.4 MEDIUM PRIORITY TEST OBJECTIVES

The following objectives have been identified as being medium-priority candidates for ACES 2.1 performance test requirements. As such, they will not be implemented until all the high-priority objectives have been implemented. As many of these objectives will be implemented as resources allow.

5.4.1 Aliased Parameters (OPS-T-5401)

The ACES shall determine the performance impact of using aliased objects as subprogram parameters.

5.4.2 Initializing Objects of Unconstrained Types (OPS-T-5402)

The ACES shall determine the performance effects of declaring objects of unconstrained types (the initial constraint being taken from the initialization expression).

5.4.3 Extension Component References (OPS-T-5403)

The ACES shall determine whether a performance cost is incurred when referencing an extension component of a tagged type.

5.4.4 Aliased Component Types (OPS-T-5404)

The ACES shall determine whether a performance cost is incurred in referencing and updating arrays and records whose components are aliased.

5.4.5 Dispatching (OPS-T-5405)

The ACES shall determine the relative performance of dispatching for various kinds of controlling operands.

5.4.6 Aliased Objects (OPS-T-5406)

The ACES shall determine the performance assignments to an aliased object and evaluations of an aliased object.

5.4.7 Accessibility Levels (OPS-T-5407)

The ACES shall determine the performance impact of using general access types to reference data at different accessibility levels.

5.4.8 Access Attribute (OPS-T-5408)

The ACES shall determine the performance characteristics of evaluations of the Access attribute.

5.4.9 Private Type Elaboration (OPS-T-5409)

The ACES shall determine the relative performance of elaboration of private type and non-private type declarations.

5.4.10 Discriminants of Non-record Types (OPS-T-5410)

The ACES shall determine the performance impact of using discriminants for tasks and for protected objects.

5.4.11 Exceptions in Accept Bodies (OPS-T-5411)

The ACES shall determine the performance impact of using exception handlers in accept bodies.

5.4.12 Exceptions in Protected Operations (OPS-T-5412)

The ACES shall determine the performance characteristics of exception propagation from protected subprograms and entries of protected objects.

5.4.13 Representation Clauses (OPS-T-5413)

The ACES shall determine the performance impact of the use of representation clauses that have been added to the language.

5.4.14 Bit_Order Attribute (OPS-T-5414)

The ACES shall determine the performance characteristics of evaluations of the Bit_Order attribute.

5.4.15 Unchecked Conversion (OPS-T-5415)

The ACES shall determine the performance impact of using unchecked conversion to produce valid and invalid values of a type. 5.4.16 Unchecked Access (OPS-T-5416)

The ACES shall determine the performance impact of using the Unchecked_Access attribute to create access values.

5.4.17 Storage Management (OPS-T-5417)

The ACES shall determine the performance characteristics of evaluations of the Storage_Pool and Storage_Size attributes for access subtypes.

5.4.18 Characters.Handling Operations (OPS-T-5418)

The ACES shall determine the performance characteristics of the operations declared in package Ada.Characters.Handling.

5.4.19 Wide_Character Operations (OPS-T-5419)

The ACES shall determine the performance characteristics of Wide_Character operations.

5.4.20 Wide_String Operations (OPS-T-5420)

The ACES shall determine the performance characteristics of Wide_String operations.

5.4.21 Wide_String Representation of Scalar Values (OPS-T-5421)

The ACES shall determine the performance characteristics of conversions between enumeration or numeric (integer, modular, float, fixed, decimal) types and Wide_String, using attributes and instantiations of the generic IO packages in Wide_Text_IO.

5.4.22 Strings.Wide_Fixed Operations (OPS-T-5422)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Wide_Fixed.

5.4.23 Strings.Wide_Bounded Operations (OPS-T-5423)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Wide_Bounded.

5.4.24 Strings.Wide_Unbounded Operations (OPS-T-5424)

The ACES shall determine the performance characteristics of the operations declared in package Strings.Wide_Unbounded.

5.4.25 Stream_IO Operations (OPS-T-5425)

The ACES shall determine the performance characteristics of the operations declared in package Streams.Stream_IO. Compare to the performance of equivalent attributes after applying the Stream function to create a Stream_Access value from the file.

6 RESOLUTION OF INCOMPATIBILITIES

During the development of ACES Version 2.0, an attempt was made to remove all Ada 95 incompatibilities from the Operational Software. However, not all incompatibilities were found. This section identifies remaining incompatibilities and states requirements for removing them.

6.1 EXTRANEOUS PACKAGE BODIES

Ada 95 library packages that do not require bodies are not permitted to have bodies. A number of the Systematic Compile Speed tests contain library packages that are illegal by this rule.

6.1.1 OPS-T-6101

Package specifications that do not require bodies but have them nevertheless shall include "pragma Elaborate_Body". See the files "sy_cum??.ada" where ?? is a two-digit integer ranging from 12 to 22.

6.2 PRAGMA PRIORITY

Two problems arise with Pragma Priority. In Ada 83, such a pragma must appear in a task declaration or the outermost declarative part of a main-program unit. In Ada 95, the pragma may have no effect if the implementation does not support the Real-Time Annex.

6.2.1 OPS-T-6201

The "dt_dp*" series of tests shall issue their calls to "put_test_name" and "delay_t" from within the body of a task with the highest priority. The expression giving the value of "actual-delay-greater-than-requested" shall use the ">=" operator. The value of this variable shall be set to False at the end of each test.

6.2.2 OPS-D-6202

The Quick-Look and Performance Testing sections of the Primer shall warn the user that the Tasking and Delay_Timing tests using pragma Priority may not behave properly for Ada 95 implementations not supporting the Real-Time Annex.

7 REQUIREMENTS FOR OTHER CHANGES

This section states requirements for any ACES Operational Software changes for Version 2.1 that are not addressed in the previous sections.

7.1 RENAMING EXISTING Ada 95 TESTS

In ACES Version 2.0, all the Ada 95 tests were placed in the Ada_95 group. These tests must be renamed into existing and new groups. The following requirements specify the renamings. These renamings imply the creation of two new groups, the Object-Oriented group (OO) and the Protected Types group (PT). They further imply the creation of new subgroups within the new and existing groups, as follows:

* In the Tasking (TK) group, the Asynchronous Transfer (AT) subgroup;
* In the Arithmetic (AR) group, the Modular Type (MT) subgroup and the
Randomization (RN) subgroup;
* In the Object-Oriented group, the Type Extension (TX) subgroup; and
* In the Protected Types group, the Protected Operations (PO) subgroup.

7.1.1 Miscellaneous Subgroup Test Renamings (OPS-T-7101)

The following tests shall be renamed:

a9_ms_atc_taken to tk_at_atc_taken_01
a9_ms_atc_not_taken to tk_at_atc_not_taken_02
a9_ms_formal_acc_subp_01 to gn_su_formal_acc_subp_01
a9_ms_formal_package_01 to gn_su_formal_package_01
a9_ms_modular_oper_01 to ar_mt_modular_oper_01
a9_ms_modular_oper_02 to ar_mt_modular_oper_02
a9_ms_random_01 to ar_rn_random_float_01

7.1.2 Object-Oriented Subgroup Test Renamings (OPS-T-7102)

The following tests shall be renamed:

a9_ob_class_wide_dynamic_01 to oo_dp_class_wide_dynamic_01
a9_ob_class_wide_static_01 to oo_dp_class_wide_static_01
a9_ob_parms_01_deriv to oo_tx_parms_deriv_01
a9_ob_parms_05_deriv to oo_tx_parms_deriv_05
a9_ob_parms_10_deriv to oo_tx_parms_deriv_10
a9_ob_ext_aggregate_01 to oo_tx_ext_aggregate_01
a9_ob_ext_aggregate_02 to oo_tx_ext_aggregate_02
a9_ob_simp_aggregate_01 to oo_tx_simp_aggregate_01
a9_ob_simp_aggregate_02 to oo_tx_simp_aggregate_02

7.1.3 Protected Type Subgroup Test Renamings (OPS-T-7103)

The following tests shall be renamed:

a9_pt_prot_access_01 to pt_po_prot_access_01
a9_pt_prot_access_02 to pt_po_prot_access_02
a9_pt_prot_access_03 to pt_po_prot_access_03

7.2 SIMPLIFICATION OF TASKING TESTS

Several of the Tasking tests are implementation-dependent. Some contain pragmas that are specific to VAX-Ada (running under VMS), while others contain deliberate syntax errors that are meant to call the user's attention to the need for adaptation. The following requirements are meant to warn the user of these dependencies before attempting to execute the tests.

7.2.1 OPS-D-7201

The Primer shall inform the user that certain Tasking tests contain references to the implementation-dependent package "Starlet" and use the implementation-dependent "AST_Entry". The Primer shall give guidance for adapting these tests to implementations other than VAX-Ada. These tests have names of the form "tk_in_int_*", where '*' ranges from 01 to 10. They appear in the files with names of the form "tk_in#_.inc", where '#' ranges from 02 to 11.

8 ABBREVIATIONS AND ACRONYMS

This section defines abbreviations and acronyms that are used in this and other ACES documents.

AARM.....Annotated Ada Reference Manual
ACEC.....Ada Compiler Evaluation Capability
ACES.....Ada Compiler Evaluation System
ACVC.....Ada Compiler Validation Capability
AES.....Ada Evaluation System (UK Ministry of Defence)
AJPO.....Ada Joint Program Office
CA.....Comparative Analysis
CISC.....Complex Instruction Set Computer
CPU.....Central Processing Unit
CRC.....Cyclic Redundancy Check
CSC.....Computer Software Component
CSCI.....Computer Software Configuration Item
DEC.....Digital Equipment Corporation
HOLCF.....High Order Language Control Facility
I/O.....Input/Output
ISA.....Instruction Set Architecture
LRM.....(Ada) Language Reference Manual (ANSI/MIL-STD-1815A)
MCCR.....Mission Critical Computer Resource
MIP.....Million Instructions Per second (a measure of hardware speed)
MIS.....Management Information System
MoD.....Ministry of Defence
NUMWG.....Numerics Working Group (ACM SIGAda organization)
RAM.....Random Access Memory
RISC.....Reduced Instruction Set Computer
RM.....(Ada 95) Reference Manual (ISO/IEC 8652 (1995))
ROM.....Read Only Memory
RTS.....Run-Time System
SSA.....Single System Analysis (ACES analysis tool)
URG.....Uniformity Rapporteur Group
VAX.....Virtual Address eXtension (DEC family of processors)
VDD.....Version Description Document
VLIW.....Very Long Instruction Word
VMS.....Virtual Memory System (DEC operating system for VAX processors)


APPENDIX A

DISPOSITION OF 1994 TEST OBJECTIVES

The Operational Software Objectives Document for ACES Version 2.0 identified 49 high-level performance test objectives as candidates for implementation in the ACES. Of these, 16 were classified as high-priority objectives, 30 were classified as medium- priority, and 3 were classified as low-priority. Some of the objectives were implemented in ACES Version 2.0. During the requirements determination process described in Section 5.1, some of the priorities were changed, some objectives were recognized as not being amenable to ACES style testing, and some were identified as being applicable only to implementations supporting particular Special Needs Annexes. A few of these objectives were also determined to be independent of Ada 95 changes.

Table A.1 indicates the disposition of each of the objectives presented in the Version 2.0 Objectives Document. The meanings of the entries in each row are as follows:

* Column 1.....Objective ID
The letter indicates the appendix in which the objective was stated. Appendix A contained the high priority objectives; Appendix B contained the medium priority objectives; and Appendix C contained the low priority objectives. The number indicates the subsection in which the objectives was discussed.

* Column 2.....Objective Title
This is the title assigned to the objective in the Version 2.0 document. (These titles are not necessarily unique.)

* Column 3.....Disposition
"V2.0" indicates that the objective was implemented in Version 2.0; "High", "Medium", and "Low" indicate that a corresponding objective appears in the current document; "Ada 83" indicates that the objective was discarded as being dependent only on Ada 83; "Annex" indicates that the objective was dependent on support for a Special Needs Annex, and was thus out of scope for this effort; "Infeasible" indicates that testing the objective would require techniques outside the current ACES paradigm.

* Column 4.....Version 2.1 Objective
This entry, which appears for those objectives having either "high" or "medium" in column 3, identifies one or more Version 2.1 objectives (appearing in this document) that cover all or part of this Version 2.0 objective.

Table A.1 Disposition of Version 2.0 Objectives

ID Title Disposition Version 2.1 Objective

A.1 Derivation Classes V2.0

A.2 Modular Types V2.0

A.3 Tagged Types & Tagged Extensions V2.0

A.4 Operations of Access Types High OPS-T-5303

A.5 Private Types and Private Extensions Medium OPS-T-5409

A.6 Assignment & Finalization High OPS-T-5306

A.7 Protected Units & Protected Objects V2.0

A.8 Protected Subprograms V2.0

A.9 Asynchronous Transfer of Control V2.0

A.10 Formal Access Types & Subprograms V2.0

A.11 Elementary Functions High OPS-T-5321

A.12 Random Number Generation V2.0

A.13 Task Priorities Annex

A.14 Priority Scheduling Annex

A.15 Entry Queuing Policies Annex

A.16 Complex Elementary Functions Annex

B.1 Extension Aggregates V2.0

B.2 Use Clauses Ada 83

B.3 Requeue Statements High OPS-T-5309 B.4

Separate Compilation High OPS-T-5312

B.5 Elaboration Control Infeasible

B.6 Exception Handlers High OPS-T-5313

B.7 Exception Handlers High OPS-T-5313

B.8 Formal Packages Infeasible

B.9 Record Layout Medium OPS-T-5413

B.10 Change of Representation Ada 83

B.11 Package System High OPS-T-5314

B.12 Unchecked Type Conversions Medium OPS-T-5415

B.13 Pragma Restrictions Annex

B.14 Streams High OPS-T-5317

B.15 String Handling High OPS-T-5318..5320

B.16 Input & Output (integer & modular) High OPS-T-5301

B.17 Wide Text Input-Output High OPS-T-5421

B.18 Stream Input-Output Medium OPS-T-5425

B.19 File Sharing Infeasible

B.20 Preelaboration Requirements Infeasible

B.21 Pragma Discard_Names Annex

B.22 Shared Variable Control Annex

B.23 Task Identification and Attributes Annex

B.24 Real-Time Systems Annex

B.25 Dynamic Priorities Annex

B.26 Preemptive Abort Annex

B.27 Tasking Restrictions Annex

B.28 Monotonic Time Annex

B.29 Delay Accuracy Annex

B.30 Asynchronous Task Control Annex

C.1 Abort of a Task Low

C.2 Suppressing Checks Low

C.3 Storage Management Medium OPS-T-5417