Embedded Linux Optimization – Tools and Techniques – On-Line Course

Register Now

You will have 180 days to access the on-line course.

Embedded Linux Optimization – Tools and Techniques

Summary – This video course provides advanced training in the debugging, testing, profiling and performance optimization of Embedded Linux software. The first part of the course focuses on advanced debugging, testing and profiling in an Embedded Linux context with a focus on using Eclipse, Backend Debuggers, JTAG and In-Circuit Emulators as well as Kernel Logging capabilities and Kernel Hacking. The latter part of the course covers performance measurement and optimization affecting boot, memory, I/O and CPU performance and key performance optimization tools for Embedded Linux software including the perf tool, advanced cache usage and compiler-based optimization.

Who Should Attend – The course is designed for real-time engineers who are developing high-performance Linux applications and device drivers using Embedded Linux distributions. It is also targeted at experienced developers requiring a refresher course on Advanced Embedded Linux optimization.

Course Objectives

• To understand debugging, profiling and testing high performance Embedded Linux software.
• To provide an overview of Linux application performance measurement and optimization.
• To understand the tools used for performance optimization of Embedded Linux software.
• To give students the confidence to apply these concepts to their next Embedded Linux project.

Lecturer – Mike McCullough is President and CEO of RTETC, LLC. Mike has a BS in Computer Engineering and an MS in Systems Engineering from Boston University. He has held a variety of software engineering positions at LynuxWorks, Embedded Planet, Wind River Systems and Lockheed Sanders. RTETC, LLC provides real-time embedded training and consulting to many embedded systems companies. RTETC focuses on real-time operating systems (RTOS), Linux and Android solutions for the embedded systems market.

Getting Started with Embedded Linux
Embedded Linux Training Overview
Linux Versioning
Building the Kernel Source Code
Embedded Linux Kernels
BSPs and SDKs
Linux References (Books and Online)
A Development Cycle Focused on Performance
A Basic Optimization Process

Basic Debugging Review
Embedded Applications Debug
GDB, GDB Server and the GDB Server Debugger
Other Debuggers
An Eclipse Remote Debug Example
Debugging with printk, syslog, syslogd and LTTng

System-Level Debug
System-Level Debug Tools
The /proc and /sys Filesystems
Basic Logging
Crash Dumps and Post-Mortem Debugging

Debugging Embedded Linux Systems
Backend Debuggers
In-Circuit Emulators
Hardware Simulators

Requirements Development
Performance Requirements
Derived Requirements
Testability and Traceability
Reviewing Requirements

Designing for Performance
Design for Test (DFT)
Agile Software Design
Software and Linux Decomposition
Memory Management
CPU and OS Partitioning
Design Reviews

Coding for Performance
Coding Standards and Consistency
Languages, Libraries and Open Source Components
Learning Magic Numbers
Letting Compilers Work For You
Global, Static and Local Variables
Code Reviews

Software Testing
Unit-Level Testing
System-Level Testing
Code Coverage Tools
Automated Testing
Some Embedded Linux Test Recommendations

Configuring DebugFS
DebugFS Capabilities

Advanced Logging
Using Logwatch and Swatch
Using syslogd and syslog-ng

ptrace and strace
New Tracing Methods
Ftrace, Tracepoints and Event Tracing
Tracehooks and utrace

Basic Profiling
gprof and Oprofile
Performance Counters
Another DDD Example

Manual Profiling
Instrumenting Code
Output Profiling

Addressing Performance Problems
Types of Performance Problems
Using Performance Tools to Find Areas for Improvement
Application and System Optimization
CPU Usage Optimization
Memory Usage Optimization
Disk I/O and Filesystem Usage Optimization

Measuring Embedded Linux Performance
Some Ideas on Performance Measurement
Common Considerations
Uncommon Considerations
Using JTAG Methods
BootLoader Measurements
Boot Time Measurements

The Perf Tool
Origins of Perf
The Perf Framework
Perf Commands and Using Perf
Listing Events
Counting Events
Profiling with Perf
Static Tracing with Perf
Dynamic Tracing with Perf
Perf Reporting

Performance Tool Assistance
Recording Commands and Performance
System Error Messages and Event Logging
Dynamic Probes
Jprobes and Return Probes
Kernel Probes
Kexec and Kdump

Improving Boot Performance
Boot Time Optimization
The Linux Fastboot Capability
Building a Smaller Linux
Building a Smaller Application
Filesystem Tips and Tricks
Some Notes on Library Usage

Improving Kernel Performance
Kernel Hacking
Configuring printk
Test Code
Configuring Kernel and IO Scheduling

Improving CPU Performance
Run Queue Statistics
Context Switches and Interrupts
CPU Utilization
Linux Performance Tools for CPU
Process-Specific CPU Performance Tools
Stupid Cache Tricks

Improving System Memory Performance
Memory Performance Statistics
Linux Performance Tools for Memory
Process-Specific Memory Performance Tools
More Stupid Cache Tricks

Improving I/O and Device Driver Performance
Disk, Flash and General File I/O

Improving Overall Performance Using the Compiler
Basic Compiler Optimizations
Architecture-Dependent and Independent Optimization
Code Modification Optimizations
Feedback Based Optimization
Application Resource Optimization
The Hazard of Trust
An Iterative Process for Optimization
Improving Development Efficiency

The Future of Linux Performance Tools

Some Final Recommendations

Course Fee: $250.00

Refund Policy:  No refunds for online courses once the course is accessed by the attendee