Download finding the view PDF

Titlefinding the view
LanguageEnglish
File Size18.3 MB
Total Pages436
Table of Contents
                            About this Document
	Intended Readers
	Document Conventions
Section 1. Getting Started
	Introduction
	Support
	Lite, Pro and Premium Versions
	Preparing for Start
		Workspaces & Projects
		Perspectives & Views
			Views
	Starting the Program
		Starting With Different Language
		Change What is Started
	Creating a New Project
		One-Click Example Project Installation
		Using an Existing Project
		Creating a Static Library
		Creating a Makefile Project From Existing Code
		Importing From Processor Expert®
	Configuring the Project’s Build Settings
		Build Configurations
			Create a New Build Configuration for Release
		Source Folders
		Include Libraries
		Compiler Optimization
		Link Time Optimization (LTO)
		Changing Toolchain Version
			Create a New Build Configuration For an Old Toolchain Version
		Creating a .hex-File
		Temporary Assembly File
	Building the Project
		Enable Parallel Build
		Enable Build on Save
		Rebuild Project
		Build All Projects
		Build All Build Configurations
		Headless Build
		Logging
		The Build Size
		Command Line Patterns
			Create .list-Files
		Building One File
	Linking the Project
		Referring Project
		Dead Code Removal
		Linker Script
		Generate a New Linker Script
			Automatically
			Manually
		Include Additional Object Files
		Adding Code to be Executed Before Main()
		Place Code In a New Memory Region
		Place Variables at Specific Addresses
		Linking In a Block of Binary Data
	Managing Existing Workspaces
		Backup of Preferences for a Workspace
		Copy Properties Between Workspaces
		Keeping Track on Java Heap Space
		Unlocking Locked Workspaces
	Managing Existing Projects
		Edit
			Quickly Find and Open a File
			Branch Folding
		The Index
		Finding Include Paths, Macros etc.
		Locate Where a File is Included
		Creating Links to External Files
		Converting a C-Project to a C++-Project
	I/O Redirection
	Position Independent Code
	Installing 3rd Party Plugins
		Integrate Freescale® Processor Expert®
			Download Processor Expert Eclipse plugin
			Extract Processor Expert® Plugin
			Install Updater
				Choose Items
				Finish Installation of Updater
			Install PEx Driver Suite
			Open Processor Expert Perspectives
	Miscellaneous Tools
		Quick Access Search Bar
		Version control
			Subversion - SVN
			Locks in SVN
			Include SVN Revision-Number in a String
			Ignore a File
			Local SVN Repository
		Multi Monitor Support
		Open Additional Instance of TrueSTUDIO
		Shell Access
			Japanese Encoding in Shell
Section 2. Debugging
	Introduction to Debugging with TrueSTUDIO
	Starting the Debugger
		External GDB Server
		JTAG Scan Chain
	The Startup Script
	Managing the Debug Configurations
	Customize the Debug Perspective
	Debugging
		Terminate, Rebuild and Re-launch
		Disassembly View
		Breakpoints
			Conditional Breakpoint
		Expressions
		Live Expressions
		Local Variables
		Fill Memory with a Byte Pattern
		SFRs
		Fault Analyzer
			Fault Analyzer View
		Terminal View
			Segger Real Time Terminal
	Stopping the Debugger
	Upgrading the GDB Server
	Configure Segger’s GDB Server
		Change Flash Caching
		Enable Log File
		Settings Command Line Option
	P&E GDB Server for Kinetis® Devices
		Licensing
		Setting the GDB Server Preferences
		Using and Configuring the Debugger
		Configuring the GDB Server
		How to Start Debug With the P&E GDB Server
		Freescale Freedom Board Configuration
			Enter OpenSDA Bootloader Mode
			Download Flash Firmware
			Update the MSD Flash Programmer Application
			Install the DEBUG_APP
		OSBDM Configuration
	OpenOCD GDB Server
	Debugging Two Targets at the Same Time
		First Alternative - Local GDB-server Using GUI Options
		Second Alternative - Remote GDB-server Using Command-line Options
	Using ST-Link Utility Inside Atollic TrueSTUDIO
		Requirements
		Steps That Needs to be Performed
		Setup ST-Link Utility as an External Tool
		Convert the Build Output to Intel Hex
		Modify the Debug Configuration
		Create a Launch Group
		Finished
Section 3. Serial Wire Viewer Tracing
	Using Serial Wire Viewer Tracing
		Serial Wire Debug (SWD)
		Serial Wire Output (SWO)
		Serial Wire Viewer (SWV)
		Instrumentation Trace Macrocell (ITM)
	Starting SWV Tracing
	The SWV Views
		The Timeline Graphs
		Statistical Profiling
		Exception Tracing
			Exception Data
			Exception Statistics
	Printf() Redirection over ITM
	Change the Trace Buffer Size
	Common SWV Problems
Section 4. Instruction Tracing
	Instruction Tracing
		Enable Trace
			Writing a Trace Port Configuration File
		Configuring the Tracing Session
		ETM Trace Port Configuration File Reference
		Add Trace Trigger
			Add Trace Trigger in the Editor
		Managing Trace Triggers
		Start Trace Recording
		Analyzing the Trace
			Display Options
			Search the Trace Log
		Exporting a Trace Log
Section 5. RTOS-Aware Debugging
	RTOS Kernel Awareness Debugging
	Segger embOS
		Requirements
		Finding the Views
		System Information
		Task List
		Timers
		Resource Semaphores
		Mailboxes
	HCC Embedded eTaskSync
		Requirements
		Finding the View
		Task List
	FreeRTOS and OpenRTOS
		Requirements
		Finding the Views
		Task List
		Queues
		Semaphores
		Timers
	Freescale MQX
		Requirements
		Finding the View
		Task Summary
		Task Details
	Quadros RTXC
		Requirements
		Finding the Views
		Kernel Information
		Tasks (Task List and Stack Info)
			Task List tab
			Stack Info tab
		Alarms
		Counters
		Event Sources
		Exception Backtrace
		Exceptions
		Mailboxes
		Mutexes
		Partitions
		Pipes
		Queues
		Semaphores
	Express Logic ThreadX
		Requirements
		Finding the Views
		Thread List
		Semaphores
		Mutexes
		Message Queues
		Event Flags
		Timers
		Memory Block Pools
		Memory Byte Pools
	TOPPERS/ASP
		Requirements
		Finding the Views
		Tasks
			Static Information Tab
			Current Status Tab
		Dataqueues
			Static Information Tab
			Current Status Tab
		Event Flags
			Static Information Tab
			Current Status Tab
		Mailboxes
			Static Information Tab
			Current Status Tab
		Memory Pools
			Static Information Tab
			Current Status Tab
		Cyclic Handlers
			Static Information Tab
			Current Status Tab
		Alarm Handlers
			Static Information Tab
			Current Status Tab
		Prioritized Dataqueues
			Static Information Tab
			Current Status Tab
		System Status
		Interrupt Line Configuration
		Interrupt Handler Static Information
		CPU Exception Handler Static Information
	Micrium µC/OS-III
		Requirements
		Finding the Views
		System Information
		Task List
		Semaphores
		Mutexes
		Message Queues
		Event Flags
		Timers
		Memory Partitions
Section 6. Source Code Review
	Introduction to Code Reviews
	Planning a Review – Review ID Creation
		Creating a Review ID
		Tailoring a Review ID Template
	Conducting a Source Code Review
		Individual Phase
		Team Phase
		Rework Phase
		Additional Settings
Section 7. Static Code Analysis
	Introduction
		Coding Standards Compliance
		Source Code Metrics
		Reports
	Selecting Coding Standard Rules
	Running a Code Inspection
	Analyzing the Results
		The Violation Summary View
		The Rule Description View
		Violation View
		Introduction to Code Complexity Analysis
		Recommended Level of Code Complexity
		When to Do Code Analysis
		The Code Metrics View
	Generate a Report
	Remove Analysis Results
	Summary
Section 8. Test Automation
	Introduction
		Function Tests
		Integration Tests
		Concepts
	Function Testing Tutorial
		The Code to Be Tested
		Initial Steps
		Excluding Files and Folders
		Adding Functions to Test
		Define Expected Results
			Defining Advanced Types of Expected Values
		Running Tests
		Analyzing the Test Results
		Analyzing the Test Quality
		Advanced Input and Output Dependencies
	Integration Test Tutorial
		The Code to Be Tested
		Creating the Test Scenario
	Managing the Test Configuration
		Managing Test Suites
		Managing Tests
		Managing Test Cases
	Setup and Teardown Code
		Creating Setup and Teardown Definitions
		Adding Code
		Using Setup and Teardown Definitions
	Detailed Test Control
		Test Drivers
		Instrumentation Macros
			Input Macros
			Test Result Macros
			Output Macros
			Other Macros
		Testing String Variables
	Generate Reports
	Important Notes
		Project Sharing
		Synchronize TrueVERIFIER
Section 9. Test Quality Measurement
	Introduction
		Why Perform Code Coverage Analysis?
		Different Types of Analysis
			Block Coverage
			Function Coverage
			Function Call Coverage
			Branch Coverage
		Tool Support
	Performing Code Coverage Analysis
		Preparations
		Starting Code Coverage Analysis
	Generate a CSV-File
	Measurement Strategy and Resource Usage
                        
Document Text Contents
Page 2

mailto:[email protected]
http://www.atollic.com/
mailto:[email protected]
http://www.atollic.com/

Page 436

Test Quality Measurement





436 | P a g e


MEASUREMENT STRATEGY AND RESOURCE
USAGE
Some code coverage solutions are based on analyzing recorded instruction trace data.
Using this methodology, the size of the recorded data is massive even for very short
measurement periods. For example, a JTAG probe with a 16MB compressed trace buffer
can typically store a test run of about 0.1 seconds only on a 168MHz Cortex-M4. The 16MB
compressed trace buffer expands to about 200MB of data in uncompressed machine
readable format, and about 2GB in human readable format. Even with gigabytes of
recorded trace data, only short periods of execution time can be measured. This strategy is
thus not working for test quality measurement during system tests that are non-trivial in
length.

As fractions of seconds is typically not enough to test and debug the quality of real-world
test procedures (as system tests typically involves users pushing buttons, stepper motors
move mechanics, and pumps pour water into washing machines, interaction with other
systems is required, etc.), a different approach is needed.

For this reason, Atollic TrueANALYZER uses instrumentation instead of instruction trace
recordings. This enables unlimited execution time, since the time of execution does not at
all affect the amount of data that is recorded.

On the other hand, the instrumentation uses some memory resources in the target board:

 In general, the need of RAM memory in the target board equals to the sum of the
cyclomatic value of code complexity + 1 of all functions being instrumented. So if
the application has two functions; one function with code complexity level 12,
and the other function having a code complexity level of 7, then the total RAM
usage will be (12+1) + (7+1) = 21 bytes. Branch decisions with multiple conditions
also add one byte of RAM usage for each condition.

 In general, the need of Flash memory in the target board scales with the total
sum of the cyclomatic value of code complexity of all functions in the application
being analyzed, although the exact number of bytes being used depends on many
factors, including compiler version and optimization level.



In case the instrumented application becomes too large to fit in the target board, it is
possible to exclude files, and folders of files, from instrumentation, thus only
instrumenting parts of the system.

Similer Documents