Embedded Linux Optimization

Register Now

Spring 2017 Course

Dates: Wednesdays, May 10, 17, 24 and 31

Time: 6 – 9 pm

Decision date: Monday, May 1

Early Registration Date deadline: Friday, April 28

Before Early Registration Date:
Members $395
Non-members $415

After Early Registration Date:
Members $415
Non-members $435

WHERE: Crowne Plaza Hotel
15 Middlesex Canal Park Drive
Woburn, MA 01801
USA

Phone 781-245-5405
email sec.boston@ieee.org
Fax 781-245-5406

If paying by check, the check must be received before the appropriate dates for Early Registration and Decision Dates.

Make Checks payable and send to:
IEEE Boston Section
One Centre Street, Suite 203
Wakefield, MA 01880

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.

Course Summary – This 4-day technical training 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.

Course Schedule Day 1
Getting Started with Embedded Linux
Embedded Linux Training Overview
Terminology
Linux Versioning
The GPL
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
KDB and KGDB
Crash Dumps and Post-Mortem Debugging
Debugging Embedded Linux Systems
Backend Debuggers
In-Circuit Emulators
Hardware Simulators
Analyzers

Course Schedule Day 2
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
gcov
Automated Testing
Some Embedded Linux Test Recommendations
DebugFS
Configuring DebugFS
DebugFS Capabilities
Advanced Logging
LogFS
Using Logwatch and Swatch
Using syslogd and syslog-ng
Tracing
ptrace and strace
New Tracing Methods
SystemTap
Ftrace, Tracepoints and Event Tracing
Tracehooks and utrace
Profiling
Basic Profiling
gprof and Oprofile
Performance Counters
LTTng
Another DDD Example
Manual Profiling
Instrumenting Code
Output Profiling
Timestamping

Course Schedule Day 3
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

Course Schedule Day 4
Improving Kernel Performance
Kernel Hacking
CONFIG_EMBEDDED
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