#Overview
This page shows performance measurements and comparison tables among the different classes of XDS Debug Probes (JTAG Emulators). It is not intended as an official benchmark and should be used for reference only, as the procedure depicted here is limited when compared to real-world debugging scenarios.
- It uses Code Composer Studio's Debug Server Scripting (DSS) feature that allows running JTAG debug sessions from the command line
- The use of DSS allows the benchmark process to be automated and reduce the influence of the graphical IDE in the measurements
- It is focused on two major types of tests: throughput and interactive
- The throughput tests perform data transfers to/from the target and measure the time elapsed to complete them.
- The interactive tests perform a sequence of typical debug operations such as single step or display a series of printf statements (console output) that are relevant to the overall user experience.
- The benchmarks chosen are very useful to compare the different JTAG debug probes.
For previous results, please check the [2017 Results](appnote-debug_probe_performance_results_2017.html) and the [2015 Results](https://processors.wiki.ti.com/index.php/XDS_Performance_comparison_2015)
#Test setup
[[+y Expand for details about the Test Setup
The base host PC used specification is:
- Dell Optiplex 7010
- Core i7-3770 (Quad core, HT enabled, 3,40GHz)
- 16GB 800MHz DDR3 Non-ECC SDRAM
- Western Digital WDC5000AAKX
- Windows 7 Professional 64 bits
Software components:
- Code Composer Studio 9.3.0.0001
- BlackHawk emupack 9.0.0.002
- Spectrum Digital emupack 5.2.0.14
- TI Emulators 8.4.0.00006 (F280049C results use version 9.1.0.00001)
- Segger Jlink SW 6.44b
- Segger Jlink CCS support 6.44.0b
- BH560v2 firmware rev 5.0.573.0
- XDS200 firmware rev 1.0.0.9
- XDS110 firmware rev 3.0.0.7
- MSP432 device support 7.2.4
- C2000 Emulation Flash 1.0.0.5
- C2000 Device support 6.0.1.0
- CC26x2 device support 3.12.0.79
- CC323x device support 1.0.5
- C6000 Device support 1.1.6
- Keystone2 Device support 1.2.3
- Sitara device support 1.4.8
- TI Tiva/Stellaris device support 2.1.1.15071
Notes:
All JTAG TCLK speeds are 10.368MHz except where noted
All Debug probes are operating in JTAG mode except where noted
+]]
##Important note about JTAG TCLK frequencies:
[[+y Expand for details about TCLK
Some of the emulators allow setting limits to the JTAG TCLK frequency from the CCS Target Configuration editor, which can potentially increase the debugging and loading speed.
However, at the moment of connection the emulator performs some tests on the JTAG serial connection and automatically chooses a reliable TCLK speed, which can be lower than the setting configured in CCS. The most obvious practical effect is that some of the tests below show the same throughput even when setting different TCLK speeds.
For details on the JTAG emulator and board design constraints that affect performance, check the [XDS Target Connection Guide](../xdsdebugprobes/emu_xds_target_connection_guide.html).
The XDS560v2 emulators actually report back the reliability of the JTAG TCLK measurements when the Test Connection button is used from the CCS Target Connection editor, and it is shown as:
The IR/DR scan-path tests used 50.00MHz as the final frequency.
-----[Measure the source and frequency of the final JTAG TCLKR input]--------
The frequency of the JTAG TCLKR input is measured as 49.99MHz.
This helps to know the actual speed being used by the JTAG debugger.
+]]
#Test results sorted by device
##MSP432E401Y
Target board: MSP432E connected Launchpad
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##MSP432P4111
Target board: MSP432P4111 Launchpad
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##CC2652R1
Target board: CC26X2R1 Launchpad
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##CC3235SF
Target board: CC3235SF Launchpad
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##AM5749
Target board: AM574x IDK
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to DDR (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##66AK2G12 A15
Target board: 66AK2G12 EVM
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to DDR (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##AM3359
Target board: BeagleBone Rev A4 with TI 20-pin connector
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to DDR (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##RM46L852
Target board: RM46L852 Launchpad
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##66AK2G12 C66
Target board: 66AK2G12 EVM
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to DDR (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##C6748
Target board: C6748 LCDK
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to DDR (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##F28379D
Target board: TMS320F28379D controlCARD
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##F280049C
Target board: TMS320F280049C controlCARD
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
##F28335
Target board: TMS320F28335 controlCARD
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.

Executable (.out) load to Flash (kB/s)
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
The Console I/O test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.

Console I/O output (ms/char)
The Single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.

Single step operations (ms/step)
#Test results sorted by type of test
##Throughput tests
The tests on this section focus on data throughput from the host PC to the target processor to compare the performance of different emulators and JTAG settings.
Note: For MCUs the executable is loaded/executed in Flash and the binaries to SRAM, while for EPs the external RAM is used in all tests.
###Executable Load
The Executable Load throughput test performs a standard program load of an ELF executable to the target device's program memory. The program contains a large data array whose size varies depending on the device's amount of available memory.
####Load results on Cortex M4
Target device: MSP432E401Y (MSP432E connected Launchpad)

Executable (.out) load to Flash (kB/s)
Target device: MSP432P4111 (MSP432P4111 Launchpad)

Executable (.out) load to Flash (kB/s)
Target device: CC2652R1 (CC26X2R1 Launchpad)

Executable (.out) load to Flash (kB/s)
Target device: CC3235SF (CC3235SF Launchpad)

Executable (.out) load to Flash (kB/s)
####Load results on Cortex A15
Target device: AM5749 (AM574x IDK)

Executable (.out) load to DDR (kB/s)
Target device: 66AK2G12 (66AK2G12 EVM)

Executable (.out) load to DDR (kB/s)
####Load results on Cortex A8
Target device: AM3359 (BeagleBone Rev A4 with TI 20-pin connector)

Executable (.out) load to DDR (kB/s)
####Load results on Cortex R4F
Target device: RM46L852 (RM46L852 Launchpad)

Executable (.out) load to Flash (kB/s)
####Load results on C6600
Target device: 66AK2G12 (66AK2G12 EVM)

Executable (.out) load to DDR (kB/s)
####Load results on C6740
Target device: C6748 (C6748 LCDK)

Executable (.out) load to DDR (kB/s)
####Load results on F2800
Target device: TMS320F28379D (TMS320F28379D controlCARD)

Executable (.out) load to Flash (kB/s)
Target device: TMS320F280049C (TMS320F280049C controlCARD)

Executable (.out) load to Flash (kB/s)
Target device: TMS320F28335 (TMS320F28335 controlCARD)

Executable (.out) load to Flash (kB/s)
###Binary Load/Save
The Binary Load/Save throughput tests perform a direct memory load/save to the target device's RAM memory. The binaries are created using the tiobj2bin utility applied to the executables of the previous test, and thus their sizes vary accordingly.
Note: results in red seem to have been skewed by cache mechanisms.
####Bin results on Cortex M4
Target device: MSP432E401Y (MSP432E connected Launchpad)

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms
Target device: MSP432P4111 (MSP432P4111 Launchpad)

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms
Target device: CC2652R1 (CC26X2R1 Launchpad)

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
Target device: CC3235SF (CC3235SF Launchpad)

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
####Bin results on Cortex A15
Target device: AM5749 (AM574x IDK)

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
Target device: 66AK2G12 (66AK2G12 EVM)

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
####Bin results on Cortex A8
Target device: AM3359 (BeagleBone Rev A4 with TI 20-pin connector)

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
####Bin results on Cortex R4F
Target device: RM46L852 (RM46L852 Launchpad)

Binary (.bin) load to SRAM (kB/s)

Binary (.bin) save from SRAM (kB/s)
####Bin results on C6600
Target device: 66AK2G12 (66AK2G12 EVM)

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
####Bin results on C6740
Target device: C6748 (C6748 LCDK)

Binary (.bin) load to DDR (kB/s)

Binary (.bin) save from DDR (kB/s)
####Bin results on F2800
Target device: TMS320F28379D (TMS320F28379D controlCARD)

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
Target device: TMS320F280049C (TMS320F280049C controlCARD)

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
Target device: TMS320F28335 (TMS320F28335 controlCARD)

Binary (.bin) load to SRAM (kB/s) - results in red seem to have been skewed by cache mechanisms

Binary (.bin) save from SRAM (kB/s)
##Interactive tests
###Console I/O comparison
This test performs a sequence of printf() calls triggered by a well-known recursive program called Towers of Hanoi with 9 disks, which yields 511 console messages printed in sequence of movements.
Note: this test is useful to compare debug probes, as the actual elapsed time is dependent on the RTS implementation and the device itself.
####CIO results on Cortex M4
Target device: MSP432E401Y (MSP432E connected Launchpad)

Console I/O output (ms/char)
Target device: MSP432P4111 (MSP432P4111 Launchpad)

Console I/O output (ms/char)
Target device: CC2652R1 (CC26X2R1 Launchpad)

Console I/O output (ms/char)
Target device: CC3235SF (CC3235SF Launchpad)

Console I/O output (ms/char)
####CIO results on Cortex A15
Target device: AM5749 (AM574x IDK)

Console I/O output (ms/char)
Target device: 66AK2G12 (66AK2G12 EVM)

Console I/O output (ms/char)
####CIO results on Cortex A8
Target device: AM3359 (BeagleBone White Rev A4 with TI 20-pin connector)

Console I/O output (ms/char)
####CIO results on Cortex R4F
Target device: RM46L852 (RM46L852 Launchpad)

Console I/O output (ms/char)
####CIO results on C6600
Target device: 66AK2G12 (66AK2G12 EVM)

Console I/O output (ms/char)
####CIO results on C6740
Target device: C6748 (C6748 LCDK)

Console I/O output (ms/char)
####CIO results on F2800
Target device: TMS320F28379D (TMS320F28379D controlCARD)

Console I/O output (ms/char)
Target device: TMS320F280049C (TMS320F280049C controlCARD)

Console I/O output (ms/char)
Target device: TMS320F28335 (TMS320F28335 controlCARD)

Console I/O output (ms/char)
###Step comparison
The single step interactive test performs 500 assembly step into operations using a valid program loaded to the target device's program memory.
####Step results on Cortex M4
Target device: MSP432E401Y (MSP432E connected Launchpad)

Single step operations (ms/step)
Target device: MSP432P4111 (MSP432P4111 Launchpad)

Single step operations (ms/step)
Target device: CC2652R1 (CC26X2R1 Launchpad)

Single step operations (ms/step)
Target device: CC3235SF (CC3235SF Launchpad)

Single step operations (ms/step)
####Step results on Cortex A15
Target device: AM5749 (AM574x IDK)

Single step operations (ms/step)
Target device: 66AK2G12 (66AK2G12 EVM)

Single step operations (ms/step)
####Step results on Cortex A8
Target device: AM3359 (BeagleBone Rev A4 with TI 20-pin connector)

Single step operations (ms/step)
####Step results on Cortex R4F
Target device: RM46L852 (RM46L852 Launchpad)

Single step operations (ms/step)
####Step results on C6600
Target device: 66AK2G12 (66AK2G12 EVM)

Single step operations (ms/step)
####Step results on C6740
Target device: C6748 (C6748 LCDK)

Single step operations (ms/step)
####Step results on F2800
Target device: TMS320F28379D (TMS320F28379D controlCARD)

Single step operations (ms/step)
Target device: TMS320F280049C (TMS320F280049C controlCARD)

Single step operations (ms/step)
Target device: TMS320F28335 (TMS320F28335 controlCARD)

Single step operations (ms/step)