You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/_index.md
+2-2Lines changed: 2 additions & 2 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,5 +1,5 @@
1
1
---
2
-
title: Sampling CPython with Arm SPE with WindowsPerf
2
+
title: Sampling CPython WindowsPerf and Arm SPE
3
3
draft: true
4
4
cascade:
5
5
draft: true
@@ -16,7 +16,7 @@ learning_objectives:
16
16
17
17
prerequisites:
18
18
- Windows on Arm desktop or development machine with [WindowsPerf](/install-guides/wperf), [Visual Studio](/install-guides/vs-woa/), and [Git](/install-guides/git-woa/) installed.
19
-
- The system must also have an Arm CPU with SPE support.
19
+
- The Windows on Arm system must have an Arm CPU with SPE support.
Copy file name to clipboardExpand all lines: content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/windowsperf_sampling_cpython_spe.md
+4-3Lines changed: 4 additions & 3 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -4,7 +4,7 @@ title: An overview of CPython sampling with SPE
4
4
weight: 2
5
5
---
6
6
7
-
In this example, you will build a debug build of CPython from sources and execute simple instructions in the Python interactive mode to obtain WindowsPerf sampling results from the CPython runtime image.
7
+
In this example, you will build a debug build of CPython from source and execute simple instructions in the Python interactive mode to obtain WindowsPerf sampling results from the CPython runtime image.
8
8
9
9
## Introduction to the Arm Statistical Profiling Extension (SPE)
10
10
@@ -21,7 +21,8 @@ WindowsPerf includes `record` support for the Arm Statistical Profiling Extensio
21
21
SPE is an optional feature in ARMv8.2 hardware that allows CPU instructions to be sampled and associated with the source code location where that instruction occurred.
22
22
23
23
{{% notice Note %}}
24
-
Currently SPE is available on Windows On Arm in Test Mode only!
24
+
SPE is only available on Windows on Arm in Test Mode.
25
+
Windows Test Mode is a feature that allows you to install and test drivers that have not been digitally signed by Microsoft.
25
26
{{% /notice %}}
26
27
27
28
## Before you begin
@@ -31,7 +32,7 @@ For this Learning Path you will need:
31
32
* A Windows on Arm (ARM64) native machine with pre-installed WindowsPerf (both driver and `wperf` CLI tool). Refer to the [WindowsPerf Install Guide](/install-guides/wperf/) for more details.
32
33
* Note: The [WindowsPerf release 3.8.0](https://github.com/arm-developer-tools/windowsperf/releases/tag/3.8.0) includes a separate build with Arm SPE (Statistical Profiling Extension) support enabled. To install this version download release asset and you will find WindowsPerf SPE build in the `SPE/` subdirectory.
33
34
*[Visual Studio](/install-guides/vs-woa/) and [Git](/install-guides/git-woa/) installed.
34
-
* The CPU must support the Arm SPE extension, an optional feature in ARMv8.2 hardware. You can check your CPU compatibility using the WindowsPerf command-line tool (explained below).
35
+
* The CPU must support the Arm SPE extension, an optional feature in ARMv8.2 hardware. You can check your CPU compatibility using the WindowsPerf command-line tool as explained below.
35
36
36
37
### How do I check if my Arm CPU supports the Arm SPE extension?
Copy file name to clipboardExpand all lines: content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/windowsperf_sampling_cpython_spe_example_1.md
+66-42Lines changed: 66 additions & 42 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -4,33 +4,39 @@ title: WindowsPerf sample using SPE example
4
4
weight: 3
5
5
---
6
6
7
-
## Example 1: Sampling of CPython calculating Googolplex using SPE
7
+
## Example 1: Sample CPython using SPE
8
8
9
-
{{% notice Note %}}
10
-
All the steps in these following sections are done on a native ARM64 Windows on Arm machine.
11
-
{{% /notice %}}
9
+
You can use the [CPython](https://github.com/python/cpython) binary you built from source in debug mode to compute a large integer number called a [Googolplex](https://en.wikipedia.org/wiki/Googolplex). This is a good way to stress CPython to demonstrate profiling.
10
+
11
+
The steps are:
12
+
- Pin the `python_d.exe` interactive console to an arbitrary CPU core and calculate `10^10^100`.
13
+
- Run counting and sampling to obtain event information.
12
14
13
-
You will use the pre-built [CPython](https://github.com/python/cpython) binaries targeting ARM64 from sources in the debug mode from the previous step and then complete the following:
14
-
- Pin `python_d.exe` interactive console to an arbitrary CPU core, calculate `10^10^100` expression, a large integer number [Googolplex](https://en.wikipedia.org/wiki/Googolplex) to stress the CPython application and get a simple workload.
15
-
- Run counting and sampling to obtain some simple event information.
15
+
### Pin CPython to CPU core 1
16
16
17
-
### Pin the new CPython process to a CPU core 1
17
+
You can use the Windows `start` command to execute and pin `python_d.exe` process to CPU core 1.
18
18
19
-
Use the Windows `start`command to execute and pin `python_d.exe` process to CPU core number 1. Below command is executing computation intensive calculations of `10^10^100`, a [Googolplex](https://en.wikipedia.org/wiki/Googolplex) number, with CPython.
19
+
Run the command below at a Windows Command Prompt to execute the computation intensive calculation:
The [start](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/start) command line switch `/affinity <hexaffinity>` applies the specified processor affinity mask (expressed as a hexadecimal number) to the new application. In our example decimal `2` is `0x02` or `0b0010`. This value denotes core no.`1` as `1` is a first bit in the mask, where the mask is indexed from `0` (zero).
26
+
The [start](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/start) command line `/affinity <hexaffinity>` applies the specified processor affinity mask (expressed as a hexadecimal number). In this example decimal `2` is `0x02` or `0b0010`. This value denotes core number`1` as `1` is a first bit in the mask, where the mask is indexed from `0`.
27
27
{{% /notice %}}
28
28
29
-
You can use the Windows Task Manager to confirm that `python_d.exe` is running on CPU core no. 1.
29
+
You can use the Windows Task Manager to confirm that `python_d.exe` is running on CPU core 1.
30
+
31
+
### WindowsPerf introduces SPE filters
32
+
33
+
You can specify SPE filters using the `-e` command line option with `arm_spe_0//`.
34
+
35
+
The `arm_spe_0/*/` notation is available for the `sample` and `record` commands, where `*` represents a comma-separated list of supported filters.
30
36
31
-
### SPE introduces new option for command line switch -e arm_spe_0//
37
+
Currently, filters such as `store_filter=`, `load_filter=`, and `branch_filter=`, or their short equivalents like `st=`, `ld=`, and `b=`. Use `0` or `1` to disable or enable a given filter.
32
38
33
-
Users can specify SPE filters using the `-e` command line option with `arm_spe_0//`. We've introduced the `arm_spe_0/*/` notation for the `sample` and `record` command, where `*` represents a comma-separated list of supported filters. Currently, we support filters such as `store_filter=`, `load_filter=`, and `branch_filter=`, or their short equivalents like `st=`, `ld=`, and `b=`. Use `0` or `1` to disable or enable a given filter. For example:
39
+
Here are some filter examples:
34
40
35
41
```output
36
42
arm_spe_0/branch_filter=1/
@@ -41,24 +47,31 @@ arm_spe_0/st=0,ld=0,b=1/
41
47
42
48
#### Filtering sample records
43
49
44
-
SPE register `PMSFCR_EL1.FT` enables filtering by operation type. When enabled `PMSFCR_EL1.{ST, LD, B}` define the collected types:
50
+
The SPE register `PMSFCR_EL1.FT` enables filtering by operation type.
51
+
52
+
When enabled `PMSFCR_EL1.{ST, LD, B}` defines the collected types:
53
+
45
54
-`ST` enables collection of store sampled operations, including all atomic operations.
46
55
-`LD` enables collection of load sampled operations, including atomic operations that return a value to a register.
47
56
-`B` enables collection of branch sampled operations, including direct and indirect branches and exception returns.
48
57
49
-
### Sampling using SPE the CPython application running the Googolplex calculation on CPU core 1
58
+
### Sample CPython using SPE
59
+
60
+
The command below samples the running `python_d.exe` process.
50
61
51
-
Below command will sample already running process `python_d.exe` (denoted with `--image_name python_d.exe`) on CPU core no. 1. SPE filter `ld=1` enables collection of load sampled operations, including atomic operations that return a value to a register.
62
+
The SPE filter `ld=1` enables collection of load sampled operations, including atomic operations that return a value to a register.
You can use the same sampling `--annotate` and `--disassemble` command line interface of WindowsPerf with SPE extension. See example outputs below.
69
+
You can use the same sampling `--annotate` and `--disassemble` command line interface of WindowsPerf with SPE extension. This is shown in the example output below.
59
70
{{% /notice %}}
60
71
61
-
Please wait a few seconds for the samples to arrive from the Kernel driver and then press `Ctrl+C` to stop sampling. You should see:
72
+
Please wait a few seconds for the samples to arrive from the Kernel driver and then press `Ctrl+C` to stop sampling.
73
+
74
+
You see output similar to:
62
75
63
76
```output
64
77
base address of 'python_d.exe': 0x7ff765fe1288, runtime delta: 0x7ff625fe0000
@@ -84,36 +97,44 @@ note: 'e' - normal event, 'gN' - grouped event with group number N, metric name
84
97
9.853 seconds time elapsed
85
98
```
86
99
87
-
{{% notice Note%}}
88
-
You can close the command line window with `python_d.exe` running when you have finished sampling. Sampling will also automatically end when the sample process has finished.
89
-
{{% /notice %}}
100
+
You can close the command line window running `python_d.exe` when you have finished sampling.
90
101
102
+
Sampling will also automatically end when the sampled process exits.
91
103
92
104
#### SPE sampling output
93
105
94
-
- In the above example, you can see that the majority of "overhead" is generated by `python_d.exe` executable resides inside the `python312_d.dll` DLL, in `x_mul` symbol.
95
-
- SPE sampling output contains also PMU events for SPE registered during sampling:
96
-
-`sample_pop` - Statistical Profiling sample population. Counts statistical profiling sample population, the count of all operations that could be sampled but may or may not be chosen for sampling.
97
-
-`sample_feed` - Statistical Profiling sample taken. Counts statistical profiling samples taken for sampling.
98
-
-`sample_filtrate` - Statistical Profiling sample taken and not removed by filtering. Counts statistical profiling samples taken which are not removed by filtering.
99
-
-`sample_collision` - Statistical Profiling sample collided with previous sample. Counts statistical profiling samples that have collided with a previous sample and so therefore not taken.
100
-
- Note that in sampling `....eee....e` is a progressing printout where:
101
-
- character `.` represents a SPE sample payload received from the WindowsPerf Kernel driver and
102
-
- character `e` represents an unsuccessful attempt (empty SPE fill buffer) to fetch the whole sample payload.
106
+
In the output above, you see that the majority of "overhead" generated by `python_d.exe` resides in the `python312_d.dll` DLL, in the `x_mul` symbol.
107
+
108
+
SPE sampling output also contains PMU events for the SPE registered events.
109
+
110
+
Here are some helpful definitions:
111
+
112
+
-`sample_pop` - Counts statistical profiling sample population, the count of all operations that could be sampled but may or may not be chosen for sampling.
-in source file `C:\path\to\cpython\Objects\longobject.c`, line `3591`, instruction `ldr x9, [sp, #0x20]` at address `0x4043b4` as potential hot-spot.
213
-
- in source file `C:\path\to\cpython\Objects\longobject.c`, line `3589`, instruction `ldr x8, [sp, #0x58]` at address `0x404360` as potential hot-spot.
214
-
- Function `v_isub:python312_d.dll`:
215
-
- in source file `C:\path\to\cpython\Objects\longobject.c`, line `1603`, instruction `ldr w8, [sp, #0x10]` at address `0x402a60` as potential hot-spot.
234
+
The output above shows that the function `x_mul:python312_d.dll` is a hot spot which comes from the following source code lines:
235
+
- File `C:\path\to\cpython\Objects\longobject.c`, line `3591`, instruction `ldr x9, [sp, #0x20]` at address `0x4043b4` as potential hot-spot.
236
+
-File `C:\path\to\cpython\Objects\longobject.c`, line `3589`, instruction `ldr x8, [sp, #0x58]` at address `0x404360` as potential hot-spot.
237
+
238
+
Another potential hot spot is in the function `v_isub:python312_d.dll` in the source file `C:\path\to\cpython\Objects\longobject.c`, line `1603`, instruction `ldr w8, [sp, #0x10]` at address `0x402a60`.
Copy file name to clipboardExpand all lines: content/learning-paths/cross-platform/windowsperf_sampling_cpython_spe/windowsperf_sampling_cpython_spe_example_2.md
+13-10Lines changed: 13 additions & 10 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -4,22 +4,23 @@ title: WindowsPerf record using SPE example
4
4
weight: 4
5
5
---
6
6
7
-
## Example 2: Using the `record` command to simplify things
7
+
## Example 2: Record CPython using SPE
8
8
9
-
- The `record` command spawns the process and pins it to the core specified by the `-c` option.
10
-
- A double-dash (`--`) is a syntax used in shell commands to signify end of command options and beginning of positional arguments. In other words, it separates `wperf` CLI options from arguments that the command operates on. Use `--` to separate `wperf.exe` command line options from the process you want to spawn followed by its verbatim arguments.
9
+
You can use the `record` command to spawn the Python process and pin it to the core specified by the `-c` option.
10
+
11
+
A double-dash (`--`) syntax in shell commands signifies the end of command options and beginning of positional arguments. In other words, it separates the `wperf` CLI options from the arguments passed to the profiled program, `python_d.exe`.
12
+
13
+
Run the `record` command with SPE to collect load events from SPE:
You can use the same sampling `--annotate` and `--disassemble` command line interface of WindowsPerf with SPE extension.
18
-
{{% /notice %}}
19
+
You can use the same `--annotate` and `--disassemble` command line arguments the SPE extension.
19
20
20
21
The WindowsPerf `record` command is versatile, allowing you to start and stop the sampling process easily. It also simplifies the command line syntax, making it user-friendly and efficient.
21
22
22
-
Example 2 can be replaced by these two commands:
23
+
The example above can be replaced by these two commands:
WindowsPerf is a versatile performance analysis tool that can support both software (with CPU PMU events) and hardware sampling (with SPE extension). The type of sampling it can perform depends on the availability of the Arm Statistical Profiling Extension (SPE) in the ARM64 CPU. If the Arm SPE extension is present, WindowsPerf can leverage hardware sampling to provide detailed performance insights. Otherwise, it will rely on software sampling to gather performance data. This flexibility ensures that WindowsPerf can adapt to different hardware configurations and still deliver valuable performance metrics.
32
+
WindowsPerf is a versatile performance analysis tool supporting both software (with CPU PMU events) and hardware sampling (with the SPE extension).
33
+
34
+
The type of sampling it can perform depends on the availability of the Arm Statistical Profiling Extension (SPE) in the CPU. If the Arm SPE extension is present, WindowsPerf can leverage hardware sampling to provide detailed performance insights. Otherwise, it will rely on software sampling to gather performance data. This flexibility ensures that WindowsPerf can adapt to different hardware configurations and still deliver valuable performance metrics.
32
35
33
-
Use `wperf sample`, a sampling mode, for determining the frequencies of event occurrences produced by program locations at the function, basic block, and/or instruction levels.
36
+
Use `wperf sample`, sampling mode, for determining the frequencies of event occurrences produced by program locations at the function, basic block, and/or instruction levels.
34
37
35
-
Use `wperf record`, same as sample but also automatically spawns the process and pins it to the core specified by `-c`. Process name is defined by COMMAND. User can pass verbatim arguments to the process.
38
+
Use `wperf record`, is the same as sample, but also automatically spawns the process and pins it to the core specified by `-c`. You can use `record` to pass verbatim arguments to the process.
0 commit comments