AMD CodeAnalyst Performance Analyzer for Windows is a suite of powerful tools that help developers optimize software performance. CodeAnalyst uses profiling to identify and analyze performance hotspots within an application, library, driver or kernel module. CodeAnalyst profiles both managed and native code. CodeAnalyst collects system-wide profile data with low overhead and is well-suited for multi-threaded, multi-core development. Software under analysis executes at full speed.
AMD CodeAnalyst has been succeeded by AMD’s CodeXL. With the exception of critical bug fixes, there will be no new versions of CodeAnalyst. For new features, continuous support and a unified developer tools suite, please visit AMD’s CodeXL web page and check out the CodeXL Forum. CodeAnalyst has reached end of life and is no longer supported, but is provided here without warranty as a convenience.
CodeAnalyst for Windows performs these kinds of analysis:
- Time-Based Profiling (TBP) identifies the parts of a program with the highest execution time — performance hotspots. Hotspots are the best candidates for optimization and tuning.
- Event-Based Profiling (EBP) helps diagnose performance issues within program hot-spots. For example, EBP measures hardware events such as cache misses and TLB misses in order to find opportunities to improve data access patterns.
- Instruction-Based Sampling (IBS) collects a wide range of performance information in a single measurement run. IBS precisely associates hardware events with the instructions that cause the events. This precision makes it easier to identify performance culprits. IBS is a feature of the latest generation of AMD processors (AMD Family 10h processors) and is supported by CodeAnalyst when it is available on the host platform.
- Call Stack Sampling is used in combination with TBP, EBP and IBS. It provides information on caller-callee relationships and helps identify the hottest, most frequently executed parts of a program.
- Thread Profiling produces a timeline showing thread activity on processor cores. Thread profiling can be used to identify thread affinity problems and low core utilization. It also analyzes non-local memory access to assist data placement on non-uniform memory access (NUMA) platforms.
- OpenCL profiling collects OpenCL API call and event information for both CPU and GPU kernels. The information can be summarized in aggregate, or shown in a detailed timeline. This allows for targeted performance improvements for heterogeneous computing tasks.
- Check out the “Introduction to CodeAnalyst” video.
There are three different ways to use CodeAnalyst for Windows.
- The standalone CodeAnalyst application has an easy to use interface that stages performance experiments and presents the results in graphs, tables and annotated source code. The CodeAnalyst GUI supports drill-down and navigation, providing convenient top-down performance analysis.
- CodeAnalyst is fully integrated into the Microsoft Visual Studio® environment. Developers can modify, compile, profile and analyze code within the same environment. CodeAnalyst supports Microsoft Visual Studio® 2005, 2008 and 2010.
- CodeAnalyst provides a suite of command line tools to collect, analyze and display profile data. Command line tools can be invoked within scripts (batch files) making it easy to stage and repeat performance experiments. The CodeAnalyst report tool produces textual reports (including CSV and XML formats) suitable for post-processing. Data may also be imported into the standalone CodeAnalyst application.
CodeAnalyst for Windows also provides an API which allows configuration and control of data collection, post-processing, and direct access to profile data. The API lets developers write custom tools.
CodeAnalyst for Windows has these additional key features:
- Low overhead system-wide data collection monitors both user- and kernel-space software
- Does not require modification of source code or executable binary files
- Analyzes JIT/managed code (Java, CLR) and native code
- Analyzes CPU OpenCL Kernel JIT code
- Collects CPU and memory utilization for a graphical timeline
- Project- and session-oriented GUI to organize profile data and configurations
- Predefined profiling configurations for different kinds of analysis
- Multi-level aggregation and performance summaries
- System, module, function, source and instruction level summaries
- Optional separation of profile data by core, by process and by thread
- Code density chart to quickly identify and navigate to program hot-spots
- Predefined view configurations including performance rates and ratios
- Import profile data collected via command line profiling utility into the GUI for analysis
- Export results in CSV format
- Pause and resume profiling with user-definable hot-key combinations
- Pause and resume profiling under program control via the CodeAnalyst API
- Event counting mode supported via the CodeAnalyst API
- Dynamically allocates and shares performance monitoring resource between users
- Uses counter multiplexing to collect up to 32 events in a single profiling session
- TBP profiling on non-AMD processors
- On-line help and tutorials
- General CodeAnalyst documentation
AMD CodeAnalyst Performance Analyzer for Windows Version 3.8 has many new interesting features and improvements as listed below
- CodeAnalyst now supports VS 2012 apart from VS 2008 and VS 2010.
- We have also included several bug fixes.
We have also included several bug fixes and removed some odd crashes.
AMD CodeAnalyst Performance Analyzer for Windows Version 3.5 supports our newest processors: Comal and Virgo (family 15h)! You’re invited to do your performance optimization with the latest systems. We have also included several bug fixes and removed some odd crashes. There is increased support for complex Java applications. Profiles for 64-bit drivers should now correctly locate the .sys files. Thread profiling is now supported for Family 14h processes.
AMD CodeAnalyst for Windows supports the following platforms:Windows® Server 2008, and Vista®, and Windows 7® distribution on x86 and AMD64 architectures.