1.1 About the Component Architecture Debug Interface
The Component Architecture Debug Interface (CADI) is a C++ API that enables convenient and accurate debugging of complex System on Chip (SoC) simulation platforms.
Note: CADI is deprecated. It has been replaced by the Iris debug API. CADI will continue to exist alongside Iris as an optional debug API until end-of-life and removal in May 2020.
CADI enables a caller, typically a debugger, to:
- Connect to an existing simulation or instantiate a new simulation.
- Attach to one of the simulation targets.
- Control the execution of a connected target.
- Observe and manipulate simulated hardware resources.
- Display the contents of registers and memory in
the simulation targets.
- Obtain valuable disassembly or profiling information.
Note: CADI can be used with simulation targets at any level of abstraction, such as instruction-accurate or cycle-accurate simulation platforms.
Because CADI is widely used within Arm® solutions, developers can:
- Integrate Arm models into their own design methodologies.
- Benefit from analyzing their simulation platforms with Arm development tools such as Arm Development Studio or Model Debugger for Fast Models.
CADI enables interaction with a third-party debugger to:
- Integrate a processor model
with established user base for an existing debugger.
- Support an architecture that has only a limited
range of native debuggers.
A CADI implementation provides many technical benefits such
- The interface exposes sufficient information on a target to enable describing its behavior and hardware resources. The caller does not require extra description files to analyze or visualize hardware components.
calls establish a channel for input to and output from an application
running on the target. This enables callers to:
- Interact with the target.
- Redirect target input and output to the host system the
simulation platform is running on.
Callback methods enable
the use of asynchronous method calls to the target that minimize
the impact on the behavior of the target. The target is blocked
by a single caller for only a short period.
Synchronous calls through the interface lock out other callers until the call has ended. This is often undesirable behavior. If, for example, one debugger is executing a command on the target, another debugger is blocked from stopping the target.
- Compiler support
- The design of CADI v2.0 classes and data types avoids method
calls that pass the ownership of heap memory objects between the
caller and the target. This enables interaction between tools and
models compiled with different compilers.
- Optional implementation
- Functionally separated parts of CADI can be optionally implemented.
This applies to both single method calls of the common CADI interface
and to those in independent classes of the CADI class hierarchy.