Rational Apex Embedded MARK Release Note for Rational Exec Solaris to Intel Architecture

This release note applies to Release 4.0.0 B of Rational Apex Embedded MARK to Intel Architecture for Rational Exec.

Full instructions for using this product are provided in the Using the Minimum Ada Runtime Kernel (MARK) with Rational Exec Guide.

This document is divided into the following sections:

• Special License Required for MARK Installation
• Compatibility Issues
• Documentation
• New Features in Release 4.0.0B
• Defects Resolved in Release 4.0.0B
• Known Defects
• Memory Map

Apex is shipped as a collection of tar files. The tar file containing the MARK portion of the product is encrypted. In order to decrypt and install MARK, you will need to obtain an apex.sun4.rx_power.untar.mark license feature from Rational (version 4.000). If you have previously purchased the MARK runtime add-on you can obtain this license key at no additional cost. Contact your local Rational sales representative for more information, or call 1-800-728-1212.

If the license file does not contain this feature when install is run, the MARK portion of the product will not be installed. The rest of the product will be installed as normal.

If you obtain the license at a later date, you can add it to the license file, and rerun the install and post_install commands. If you are in an apex shell, the install and post_install commands can be invoked by:

% cd $APEX_EMBEDDED_HOME/rx_*.4.0.0/install
% ./install

This will decrypt and install the MARK component. Note, this may take a while (on the order of 20 minutes).

% ./post_install

This MARK release is compatible with the Rational Apex Embedded Intel Architecture for Rational Exec version 4.0.0 B product.

Documents specific to this product are:

Release Notes for MARK Rational Exec
Using MARK with Rational Exec Guide

These documents are available in both hard-copy and online format. Online they can be accessed through the Help > Manuals command or the Doc List button in the navigation bar of each online manual page.

MARK is derived from the standard Apex Ada runtime system. Rather then create a new runtime system from scratch it is far more reliable to reuse tested components that have been developed and debugged over years of development effort. However, there is value in MARK to remove lines of code in an effort to simplify the testing effort required to certify embedded applications.

This version of MARK has simplified the runtime environment with an eye towards reducing the number of source lines required to support Ada applications. Many of the runtime components that were written to support the complexities of multiple programs, multiple tasks, separate kernel and micro kernel programs have been eliminated and replaced with MARK specific implementations. The new packages to support MARK can be found in mark.ss.

Since the standard MARK program is smaller the need for the "No Kernel" version of MARK is no longer required and has been eliminated.

The File > New > New MARK dialog has been replaced by the File > New > New Source Release dialog.

• Two exception unwinding models: .ex0 - no exceptions; .ex1 - full exception unwinding
• Three storage management models including .sm0 - no storage management
• No Kernel program configuration for extremely small footprint applications (less then 2000 bytes) for programs that do not require interrupts, delay, time, exception unwinding, and storage management
• Full C/C++ Duo support is now available
• Predefine modifications to allow pragma Restrictions(No_Allocators) for some programs.
• Set of example views for each MARK configuration and Duo example.
• File > New > New MARK dialog can be used to easily construct a MARK source area in which to begin construction of a safety critical application.

None.

The example MARK i386pc bsp uses a Link.des that sets the origin of the MARK program to 0100000. Video RAM and other memory mapped i/o are in the lower addresses of memory. By starting the program at 1M all of the problems of the program flowing into the i/o space can be ignored.