DataMuseum.dk

top - download

    Length: 7111 (0x1bc7)
    Types: TextFile
    Notes: R1k Text-file segment

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦5a81ac88f⟧ »Space Info Vol 1« 
        └─⟦473a0616c⟧ 
            └─⟦this⟧ 

TextFile

~chapter(Overview)

Interfaces in this subsystem can be used to analyze Ada units in a variety
of ways. A user may want to perform the following kinds of analysis:

~startnp

~np
~bold(General Analysis) - Analysis to collect and condense all
areas of the code that exhibit a particular trait so that an
overall picture of the code may emerge.

~np
~bold(Performance) - Analysis to illuminate areas of the code that
have potentially high impact on performance.

~np
~bold(Code Correctness) - Analysis to illuminate areas of the code
that have a high likelihood for errors given their complexity.

~np
~bold(Style) - Analysis to verify that coding standards are not violated
and that the code maintains consistent usage patterns.

~endnp

~chapter(Analysis Descriptions)

~section(General Analysis)

~subsection(Counting Ada Constructs) ~label(Counting_Ada_Constructs)

The package Ada_Construct analysis provides two interfaces for counting
the instances of Ada constructs in a collection of units.  This can be
used to find instances of Ada constructs which are prohibited and
high concentrations of usages which may indicate a problem or may
indicate a positive attribute of the code.

The first procedure (Display_By_Unit) provides a list of ada constructs
on a unit-by-unit basis, separating the counts for each unit into a
separate table.

A second procedure is available to compare the counts for all procedures
in a single table.  A total for all procedures is also provided.

Each procedure has a set of summary tables which provide totals and
average counts per unit.

~subsection(Analyze_Types) ~label(Analyze_Types)

Provides an analysis of all type declarations in a set of Ada units.
Declarations are sorted by kind so that redundant or similar
declarations can be found.

~subsection(Analyze_Record_Types) ~label(Analyze_Record_Types)

Displays all record declarations and their components located in a set
of Ada units.  Each unique record
component type is uniquely numbered.  The display is sorted to expose
records that have high degree of commonality among component types. These
records may be candidates for discrimination.

~subsection(Find_Exceptions) ~label(Find_Exceptions)

Displays all exceptions, where they are explicitly raised, and where
they are explicitly handled.

~subsection(Find_Generics) ~label(Find_Generics)

Displays all generic program units and their instantiations.  The
actual parameters to the instantiation are listed to expose commonality.

~subsection(Find_Objects) ~label(Find_Objects)

Displays all object declarations, their type, their target size in bytes,
whether they are a constant or a variable, and how many times they are
set and used.

~subsection(Find_Pragmas) ~label(Find_Pragmas)

Display all pragma used and their parameters within a set of Ada units.

~subsection(Find_Tasks) ~label(Find_Tasks)

Displays all tasks, each entry of the task, where each entry is
accepted within the task, and where it is called from external units.

~subsection(Type_Display) ~label(Type_Display)

Recursively expands any type declaration to expose all subcomponents.
Each entry has the name of the component, its ground type, and its size in
target bytes.

~subsection(Glance) ~label(Glance)

Provides a filtered display of all selected declarations removing
unwanted information such as comments, pragmas, etc.

~subsection(Call_Tree_Analysis) ~label(Call_Tree_Analysis)

Displays an analysis of procedure calls within a main unit.  The
user may follow up or down the call chain.



~section(Performance)

~subsection(Find_Allocators) ~label(Find_Allocators)

Locates all allocators (new operators), anticipating that the
management of dynamic memory is a performance issue.

~subsection(Find_Exceptions) 

Finds all exception usage anticipating that the use of exceptions for
error reporting may positively or negatively impact performance.  See
description in ~ref(Find_Exceptions) above for additional detail.

~subsection(Find_Inline_Candidates) ~label(Find_Inline_Candidates)

Finds all subprogram that have the following characteristics:

~startnp

~np
A small number of statements

~np
A small number of declarations that require elaboration

~np
A small number of call sites

~endnp

The objective is to locate subprograms that will have low code expansion
that may be suitable for inlining.  Each of the above characteristics is
a parameter of the interface.

~subsection(Find_Literals) ~label(Find_Literals)

Locates all literals.  Excessive use of string literals may be inefficient.

~subsection(Find_Objects)

Locates all objects and sorts them by their size.  Large objects may
impact performance.  See text in ~ref(Find_objects) for additional detail.

~subsection(Find_Overhead_Functions) ~label(Find_Overhead_Functions)

Locate functions that simply return a visible global variable or constant.

~subsection(Find_Pragmas)

Finds all pragmas anticipating that the use (of non-use) of certain pragmas
may impact performance.  See ~ref(Find_Pragmas) for additional detail.

~subsection(Find_Tasks)

Tasking may have an impact on performance.  See ~ref(Find_Tasks) for additional
details.

~subsection(Find_Unused_Declarations) ~label(Find_Unused_Declarations)

Locate all unused declarations and un-referenced record components.  These
may be eliminated to reduce code and elaboration time.

~subsection(Find_Unused_Withs) ~label(Find_Unused_Withs)

Finds all unused with clauses or with clauses that are only used by a rename or use clause.
Eliminating these may improve overall compile time.

~subsection(Find_Use_Clauses) ~label(Find_Use_Clauses)

Find all use clauses both on and internal to compilation units.  Use of
use clauses may reduce compilation performance.

~section(Code Correctness)

~subsection(Find_Exceptions) 

Exceptions are often a potential problem.
See ~ref(Find_Exceptions) above for additional details.

~subsection(Find_Objects)

Lists whether an object is set or used.  The lack of sets or usages may
indicate a problem.  See ~ref(Find_Objects) for additional detail.

~subsection(Find_Others_Clauses) ~label(Find_Others_Clauses)

Finds all "others" clauses in case statements, exception handlers,
aggregates. Use of these construct may cause subtle errors.

~section(Style)

~subsection(Counting Ada Constructs) 

Interfances are provided for counting the occurance of specific
Ada constructs within an Ada unit.  The existance of ada constructs
may violate or support sytle guidelines.
See ~label(Counting_Ada_Constructs) for additional detail.


~subsection (Find_Renames) ~label (Find_Renames)

Finds all renaming declarations and display the new name introduced by
the rename.  This can be used to discover inconsistencies in the
name space introduced by renames.

~subsection(Find_Use_Clauses)

Use of use clauses can reduce the readability of code.  See ~ref(Find_Use_Clauses)
for additional details.

~subsection(Find_Visible_Types)

Use of non-private type declarations may reduce the information hiding
within a program.  This interface finds all non-private types declared
in the visible part of packages.