Category:UIA

Unified Instrumentation Architecture (UIA)[edit]

The Unified Instrumentation Architecture (UIA) defines a set of tools, APIs, transports, interfaces and guidelines that enable developers to instrument embedded software in a way that is portable and flexible, and enables the creation of advanced tooling features that can be used both in the lab and in the field.

The UIA Package (version 2.x+) is a sub-component of TI-RTOS and is installed as part of the TI-RTOS Product Download (download link). It can also be downloaded separately from here

Portable and Flexible

ISA independent: can be re-used across a wide range of TI platforms, single-core devices and multi-core devices
O/S independent: not tied to any specific operating system
Transport independent: can use a wide variety of different transports to upload software events from the target to the host, without having to change the source code
Platform independent: Host-side tooling works on both Windows and Linux platforms
IDE independent: Host-side tooling will support both tight integration with Code Composer Studio and stand-alone operation for use with other IDEs.

Advanced Tooling Features

real-time event monitoring
multicore event correlation
correlation of software events, hardware events and CPU trace
real-time profiling and benchmarking
real-time debugging

It defines an instrumentation framework that enables the development of instrumentation client tools, instrumented target content, infrastructure components, and instrumentation middleware components that interoperate and can be re-used across TI platforms and devices. This framework enables the creation of interactive and script-driven tools capable of providing developers with insight into the operation and real-time dynamics of application software, software components and silicon devices within the context of the system they are running on.

The Unified Instrumentation Architecture framework includes:

a messaging infrastructure that allows instrumentation clients to interact with instrumentation endpoints on a target device while the target is running
an extensible set of commands and messages that can be sent over the messaging infrastructure
protocols to be used by the target-side instrumentation framework and the host-side instrumentation client
built-in instrumentation for DSP/BIOS for 'out of the box' real-time visibility into the operation of the O/S
guidelines on how to instrument other RTOSes

A phased roll-out of features is planned, starting with release UIA 1.0.

UIA is built on top of a number of different products, including:

Target Software packages:

  - UIA: Unified Instrumentation Architecture APIs
  - XDC: eXtended C tools and software
  - IPC: Inter-processor communications library
  - NDK: Network Developers Kit
  - BIOS: DSP/BIOS and SysBIOS RTOS

Host side tooling

  - DVT: the Data Visualization Toolkit
  - CCS: Code Composer Studio: An eclipse-based Integrated Development Environment

Software Development Kits that include UIA support:

  - MCSDK

The following links provide more information:

White Papers[edit]

A Unified Instrumentation Architecture for Real-time System Visibility

Presentations[edit]

Real-time System Visibiltiy and Debugging for Embedded Multicore Devices

Getting started[edit]

How to prepare your application for instrumentation
Tutorials

Event Logging APIs[edit]

Logging errors, warnings, and informational events
Migrating existing software instrumentation code to UIA
Benchmark events
Context Change events
Snapshot events

Event transports: Target[edit]

Ethernet transport
Saving events in a binary file
JTAG transport (UIA 1.1)
Other transports
Event Data Management: how to minimize the number of events that are 'dropped' because the upload speed is not as fast as the rate the events are generated

Event transports: Host[edit]

How to configure DVT to connect with your target
Event Data Management Features: How to cope with 'too much data' so that you still capture what you need to see
Live data processing

Analysis Features[edit]

Benchmarking: Finding out how long it takes some action to complete. Includes 'context aware' benchmarking for multi-threaded analysis
CPU and Task Load Monitoring: real-time visibility into how busy your system really is
O/S Execution Monitoring: monitoring task switches and the state of kernel objects such as semaphores
Filtering events
Multicore Event Correlation
User Interface Help