The Integrate™ utility is a unique industry-leading innovation
that enables the system designer to establish an initial
state of tasks, connections, and other kernel objects across
multiple address spaces. It enables the system designer to
verify system security and guarantee resource availability.
Integrate has a graphical front-end that enables the system
designer to configure all resources in the entire
INTEGRITY system, including address spaces, clocks, tasks,
semaphores, connections, etc., in an easy-to-use yet powerful
interface. Add new address spaces simply by clicking
and dragging the address space icon into the main canvas.
Add a task to this address space by clicking and dragging
the task icon into the newly created address space block.
Create connections between address spaces simply by
clicking and dragging the cursor from one address space to another.
Integrate also has powerful navigation capabilities,
enabling the designer to search for and locate address
spaces that are not in the viewable area of the canvas.
Large systems, consisting of dozens or even hundreds of
address spaces and thousands of tasks, are handled
seamlessly.
Integrate produces configuration files that layout the
details of the system in a convenient format for printing.
This same file is also used when the actual INTEGRITY
application is built. Use the “File Open” option to have
Integrate read the configuration file and display the contents
graphically. Integrate clearly separates the address
spaces so that they can be easily viewed and distinguished
from one another.
|
|
 |
|
|
INTEGRITY provides a target shell, accessible via telnet or rlogin, which enables the developer to communicate directly with the target, even before any application code is running. The shell enables loading and unloading of modules independent of MULTI, FTP, ping, listing of tasks and modules, setting network configuration, reading/writing target memory, and performing file system services.
| The INTEGRITY EventAnalyzer |
 |
The powerful EventAnalyzer™ enables programmers to understand the complex real-time interactions of their system. Some problems simply cannot be detected with standard debugging techniques. Important events such as semaphore calls, task context-switches, and interrupts are logged on the target in real-time. This data is transferred to the host where it’s displayed graphically in the EventAnalyzer GUI. Enabling and disabling event logging, selecting which events to track, and determining the size of target event buffers is fully controllable by the user, both interactively and programmatically.
Live or postmortem mode
Data can be logged either in postmortem mode or live mode. In postmortem mode, data is gathered in a circular buffer on the target with a minimal effect on the rest of the system; users can upload the event log upon request, such as after a failure, and analyze this information on the host to determine the root cause of the failure. In live mode, data is
continually sent to the host via TCP/IP, allowing a virtually unlimited history of data to be collected and analyzed as the system is running.
|
|
|
Optimizing compilers
Green Hills Software’s world class C, C++, Embedded C++, and Ada 95 Compilers support the INTEGRITY RTOS.
MULTI & AdaMULTI development environments
MULTI® and AdaMULTI™ are fully Integrated Development
Environments (IDEs) for embedded applications. MULTI
runs on Windows, Unix, Linux, and HP-UX hosts and supports
remote debugging to INTEGRITY targets. MULTI provides
a direct graphical interface for all Green Hills compilers
and supports multi-language development and debugging.
MULTI consists of a Project Builder, Source-Level
Debugger, Performance Profiler, Runtime Error Checking,
Graphical Browser, Text Editor, Version Control System, and
Code Coverage Profiler.
|
Third Party Integrations |
INTEGRITY is integrated with a variety of popular third party embedded products, including:
- SNMP Research—SNMP
- aicas and Apogee—Java
- Certicom—encryption (elliptic curve)
- Visuality Systems—CIFS
- McObject—in memory database
- M-System—solid state memory
- BirdStep—RDBM
- RTI—NDDS
- Extended Systems and Stone Street One—Bluetooth
- Swell Software—Portable Embedded GUI (PEG)
- Vector Software—Unit Level Testing
- Objective Interface and PrismTech—CORBA
- orbs
- Mindready—IEEE 1394
- Allegro Software—Web and email support
- ALT Software and Seaweed—OpenGL/X11/Motif
- Embedded Planet—hardware platforms
- Telelogic—UML 2.0 application modeling
- IBM Rose RealTime—application modeling
- RadVision—VOIP, SIP, RTP/RTCP
- Interpeak—IPv4/v6, security,WiFi
- IP Infusion and NextHop—OSPF, BGP4, MPLS
- Data Connection—ATM
- Open Interface—Bluetooth
- Telelogic—TAU application modeling
- ACE/TAO Open Source ORB
|
Heterogeneous multiprocessor debugging
MULTI can debug multiple INTEGRITY tasks simultaneously,
each in its own color-coded window. Breakpoints can
be set to stop one task while others are allowed to continue.
Each task can be running on a different processor, the
same processor, the ISIM simulator, or any combination of
these environments for true heterogeneous multiprocessor
debugging.
Tracepoints for field debugging
INTEGRITY’s unique tracepoint capability enables nonintrusive
data collection in running systems. When a task
hits a tracepoint, the specified registers and memory are
probed and their values stored for later view. The task
continues with only brief interruption, making tracepoints
ideal for troubleshooting or monitoring a fielded system.
Multiple-task debugging
When used with MULTI or AdaMULTI, INTEGRITY offers advanced multiple-task debugging features including:
- The ability to debug multiple tasks across multiple address spaces across multiple processors simultaneously, each task has it own debugger window.
- A task roster window for tracking the tasks in the system and choosing which tasks to debug. The task window shows useful per-task information such as name, execution status, priority, stack size, and stack use (high watermark).
- The ability to automatically bring up a new debugger window upon task creation.
- The ability to set task-specific as well as address space-wide (also called “AnyTask” or “AT”) breakpoints.
- Simultaneous multiple-task debugging support over both serial and ethernet for most boards.
- Host emulation of file and terminal I/O.
- The ability to display the relative execution time of all tasks (including the “idle” task).
Field upgrade and debugging
INTEGRITY provides special features that enable fielded systems to be easily and efficiently upgraded and debugged.
- The MULTI debugger can be attached to the fielded system and then debug it without halting the processor.
- The system can be placed into Passive Mode so that a user cannot inadvertently alter its behavior. In Passive Mode, halting of tasks and writing to memory or registers is prohibited.
- INTEGRITY provides capabilities for dynamically loading new software into RAM for live upgrades.
- INTEGRITY provides capabilities for remotely upgrading the system’s firmware (down to the address space or shared library level of granularity).
Kernel awareness
MULTI provides a comprehensive picture of kernel objects, tasks and resources, and their statuses. Even without source, developers can view a complete snapshot of INTEGRITY’s state and can:
- Debug and view virtual address spaces
- Debug and view physical address spaces
- Debug tasks in separate windows
- Debug and view virtual or physical address space tasks
- View all kernel objects (tasks, semaphores, address spaces, ...)
Task group breakpoints
INTEGRITY enables breakpoints to perform a variety of actions other than simply halting the task in which they
occurred. Supported actions include halting or resuming
any subset of the tasks on the system, or even on an entire
cluster of systems. This powerful feature allows the
debugger to take a snapshot of all related tasks and data
whenever a particular breakpoint is hit, which is extremely
useful when debugging a multi-threaded and/or multiprocessor
application.
INTEGRITY debug agent
INTEGRITY includes a powerful remote debug agent that enables remote debugging of multi-processor systems, including multiple boards and chassis, all from a single hardware network connection to the host and a single instance of the MULTI debugger. All inter-target communication is via TCP/IP across the VME or cPCI backplane, or
Ethernet, and is portable to other fabrics or mediums.
|
|
)
)
)
)
)
)
RSS
){kind=link}